Self hosted fixes (#682)
* fix compiler errors when using self-hosted * move parameters into builder struct * simplify code when using self hosted * fix stage2 error `cast discards const qualifier` * correctly return after finding method * fix position context tests on self hosted * remove unnecessary comptime in position context tests
This commit is contained in:
parent
d030dd0993
commit
51356517a9
@ -90,10 +90,13 @@ pub fn loadFromFile(allocator: std.mem.Allocator, file_path: []const u8) ?Config
|
|||||||
|
|
||||||
const file_buf = file.readToEndAlloc(allocator, 0x1000000) catch return null;
|
const file_buf = file.readToEndAlloc(allocator, 0x1000000) catch return null;
|
||||||
defer allocator.free(file_buf);
|
defer allocator.free(file_buf);
|
||||||
@setEvalBranchQuota(7000);
|
@setEvalBranchQuota(10000);
|
||||||
|
|
||||||
|
var token_stream = std.json.TokenStream.init(file_buf);
|
||||||
const parse_options = std.json.ParseOptions{ .allocator = allocator, .ignore_unknown_fields = true };
|
const parse_options = std.json.ParseOptions{ .allocator = allocator, .ignore_unknown_fields = true };
|
||||||
|
|
||||||
// TODO: Better errors? Doesn't seem like std.json can provide us positions or context.
|
// 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), parse_options) catch |err| {
|
var config = std.json.parse(Config, &token_stream, parse_options) catch |err| {
|
||||||
logger.warn("Error while parsing configuration file: {}", .{err});
|
logger.warn("Error while parsing configuration file: {}", .{err});
|
||||||
return null;
|
return null;
|
||||||
};
|
};
|
||||||
|
@ -134,7 +134,9 @@ fn loadBuildAssociatedConfiguration(allocator: std.mem.Allocator, build_file: *B
|
|||||||
const file_buf = try config_file.readToEndAlloc(allocator, 0x1000000);
|
const file_buf = try config_file.readToEndAlloc(allocator, 0x1000000);
|
||||||
defer allocator.free(file_buf);
|
defer allocator.free(file_buf);
|
||||||
|
|
||||||
break :blk try std.json.parse(BuildAssociatedConfig, &std.json.TokenStream.init(file_buf), options);
|
var token_stream = std.json.TokenStream.init(file_buf);
|
||||||
|
|
||||||
|
break :blk try std.json.parse(BuildAssociatedConfig, &token_stream, options);
|
||||||
};
|
};
|
||||||
defer std.json.parseFree(BuildAssociatedConfig, build_associated_config, options);
|
defer std.json.parseFree(BuildAssociatedConfig, build_associated_config, options);
|
||||||
|
|
||||||
@ -234,9 +236,11 @@ fn loadBuildConfiguration(context: LoadBuildConfigContext) !void {
|
|||||||
|
|
||||||
build_file.config.deinit(allocator);
|
build_file.config.deinit(allocator);
|
||||||
|
|
||||||
|
var token_stream = std.json.TokenStream.init(zig_run_result.stdout);
|
||||||
|
|
||||||
const config: BuildConfig = std.json.parse(
|
const config: BuildConfig = std.json.parse(
|
||||||
BuildConfig,
|
BuildConfig,
|
||||||
&std.json.TokenStream.init(zig_run_result.stdout),
|
&token_stream,
|
||||||
parse_options,
|
parse_options,
|
||||||
) catch return error.RunFailed;
|
) catch return error.RunFailed;
|
||||||
defer std.json.parseFree(BuildConfig, config, parse_options);
|
defer std.json.parseFree(BuildConfig, config, parse_options);
|
||||||
|
@ -1627,12 +1627,10 @@ fn exitHandler(server: *Server, writer: anytype, id: types.RequestId) noreturn {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn registerCapability(server: *Server, writer: anytype, method: []const u8) !void {
|
fn registerCapability(server: *Server, writer: anytype, method: []const u8) !void {
|
||||||
// NOTE: stage1 moment occurs if we dont do it like this :(
|
const id = try std.fmt.allocPrint(server.arena.allocator(), "register-{s}", .{method});
|
||||||
// long live stage2's not broken anon structs
|
|
||||||
|
|
||||||
log.debug("Dynamically registering method '{s}'", .{method});
|
log.debug("Dynamically registering method '{s}'", .{method});
|
||||||
|
|
||||||
const id = try std.fmt.allocPrint(server.arena.allocator(), "register-{s}", .{method});
|
if (zig_builtin.zig_backend == .stage1) {
|
||||||
const reg = types.RegistrationParams.Registration{
|
const reg = types.RegistrationParams.Registration{
|
||||||
.id = id,
|
.id = id,
|
||||||
.method = method,
|
.method = method,
|
||||||
@ -1645,7 +1643,6 @@ fn registerCapability(server: *Server, writer: anytype, method: []const u8) !voi
|
|||||||
const respp = types.ResponseParams{
|
const respp = types.ResponseParams{
|
||||||
.RegistrationParams = params,
|
.RegistrationParams = params,
|
||||||
};
|
};
|
||||||
|
|
||||||
const req = types.Request{
|
const req = types.Request{
|
||||||
.id = .{ .String = id },
|
.id = .{ .String = id },
|
||||||
.method = "client/registerCapability",
|
.method = "client/registerCapability",
|
||||||
@ -1653,6 +1650,22 @@ fn registerCapability(server: *Server, writer: anytype, method: []const u8) !voi
|
|||||||
};
|
};
|
||||||
|
|
||||||
try send(writer, server.arena.allocator(), req);
|
try send(writer, server.arena.allocator(), req);
|
||||||
|
} else {
|
||||||
|
try send(writer, server.arena.allocator(), types.Request{
|
||||||
|
.id = .{ .String = id },
|
||||||
|
.method = "client/registerCapability",
|
||||||
|
.params = types.ResponseParams{
|
||||||
|
.RegistrationParams = types.RegistrationParams{
|
||||||
|
.registrations = &.{
|
||||||
|
.{
|
||||||
|
.id = id,
|
||||||
|
.method = method,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
});
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn requestConfiguration(server: *Server, writer: anytype) !void {
|
fn requestConfiguration(server: *Server, writer: anytype) !void {
|
||||||
@ -1670,7 +1683,7 @@ fn requestConfiguration(server: *Server, writer: anytype) !void {
|
|||||||
try send(writer, server.arena.allocator(), types.Request{
|
try send(writer, server.arena.allocator(), types.Request{
|
||||||
.id = .{ .String = "i_haz_configuration" },
|
.id = .{ .String = "i_haz_configuration" },
|
||||||
.method = "workspace/configuration",
|
.method = "workspace/configuration",
|
||||||
.params = .{
|
.params = types.ResponseParams{
|
||||||
.ConfigurationParams = .{
|
.ConfigurationParams = .{
|
||||||
.items = &configuration_items,
|
.items = &configuration_items,
|
||||||
},
|
},
|
||||||
@ -1785,7 +1798,6 @@ fn semanticTokensFullHandler(server: *Server, writer: anytype, id: types.Request
|
|||||||
};
|
};
|
||||||
|
|
||||||
const token_array = try semantic_tokens.writeAllSemanticTokens(&server.arena, &server.document_store, handle, server.offset_encoding);
|
const token_array = try semantic_tokens.writeAllSemanticTokens(&server.arena, &server.document_store, handle, server.offset_encoding);
|
||||||
defer server.allocator.free(token_array);
|
|
||||||
|
|
||||||
return try send(writer, server.arena.allocator(), types.Response{
|
return try send(writer, server.arena.allocator(), types.Response{
|
||||||
.id = id,
|
.id = id,
|
||||||
@ -2429,8 +2441,8 @@ pub fn processJsonRpc(server: *Server, writer: anytype, json: []const u8) !void
|
|||||||
.{ "workspace/didChangeConfiguration", std.json.Value, didChangeConfigurationHandler },
|
.{ "workspace/didChangeConfiguration", std.json.Value, didChangeConfigurationHandler },
|
||||||
};
|
};
|
||||||
|
|
||||||
|
if (zig_builtin.zig_backend == .stage1) {
|
||||||
// Hack to avoid `return`ing in the inline for, which causes bugs.
|
// Hack to avoid `return`ing in the inline for, which causes bugs.
|
||||||
// TODO: Change once stage2 is shipped and more stable?
|
|
||||||
var done: ?anyerror = null;
|
var done: ?anyerror = null;
|
||||||
inline for (method_map) |method_info| {
|
inline for (method_map) |method_info| {
|
||||||
if (done == null and std.mem.eql(u8, method, method_info[0])) {
|
if (done == null and std.mem.eql(u8, method, method_info[0])) {
|
||||||
@ -2461,6 +2473,26 @@ pub fn processJsonRpc(server: *Server, writer: anytype, json: []const u8) !void
|
|||||||
error.HackDone => return,
|
error.HackDone => return,
|
||||||
else => return err,
|
else => return err,
|
||||||
};
|
};
|
||||||
|
} else {
|
||||||
|
inline for (method_map) |method_info| {
|
||||||
|
if (std.mem.eql(u8, method, method_info[0])) {
|
||||||
|
if (method_info.len == 1) {
|
||||||
|
log.warn("method not mapped: {s}", .{method});
|
||||||
|
} else if (method_info[1] != void) {
|
||||||
|
const ReqT = method_info[1];
|
||||||
|
const request_obj = try requests.fromDynamicTree(&server.arena, ReqT, tree.root);
|
||||||
|
method_info[2](server, writer, id, request_obj) catch |err| {
|
||||||
|
log.err("failed to process request: {s}", .{@errorName(err)});
|
||||||
|
};
|
||||||
|
} else {
|
||||||
|
method_info[2](server, writer, id) catch |err| {
|
||||||
|
log.err("failed to process request: {s}", .{@errorName(err)});
|
||||||
|
};
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Boolean value is true if the method is a request (and thus the client
|
// Boolean value is true if the method is a request (and thus the client
|
||||||
// needs a response) or false if the method is a notification (in which
|
// needs a response) or false if the method is a notification (in which
|
||||||
|
@ -1,4 +1,5 @@
|
|||||||
const std = @import("std");
|
const std = @import("std");
|
||||||
|
const zig_builtin = @import("builtin");
|
||||||
const DocumentStore = @import("DocumentStore.zig");
|
const DocumentStore = @import("DocumentStore.zig");
|
||||||
const analysis = @import("analysis.zig");
|
const analysis = @import("analysis.zig");
|
||||||
const types = @import("types.zig");
|
const types = @import("types.zig");
|
||||||
@ -242,6 +243,20 @@ fn writeCallNodeHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// HACK self-hosted has not implemented async yet
|
||||||
|
fn callWriteNodeInlayHint(allocator: std.mem.Allocator, args: anytype) error{OutOfMemory}!void {
|
||||||
|
if (zig_builtin.zig_backend == .other or zig_builtin.zig_backend == .stage1) {
|
||||||
|
const FrameSize = @sizeOf(@Frame(writeNodeInlayHint));
|
||||||
|
var child_frame = try allocator.alignedAlloc(u8, std.Target.stack_align, FrameSize);
|
||||||
|
defer allocator.free(child_frame);
|
||||||
|
|
||||||
|
return await @asyncCall(child_frame, {}, writeNodeInlayHint, args);
|
||||||
|
} else {
|
||||||
|
// TODO find a non recursive solution
|
||||||
|
return @call(.{}, writeNodeInlayHint, args);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/// iterates over the ast and writes parameter hints into `builder.hints` for every function call and builtin call
|
/// iterates over the ast and writes parameter hints into `builder.hints` for every function call and builtin call
|
||||||
/// nodes outside the given range are excluded
|
/// nodes outside the given range are excluded
|
||||||
fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *DocumentStore, maybe_node: ?Ast.Node.Index, range: types.Range) error{OutOfMemory}!void {
|
fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *DocumentStore, maybe_node: ?Ast.Node.Index, range: types.Range) error{OutOfMemory}!void {
|
||||||
@ -255,9 +270,7 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
|
|
||||||
if (node == 0 or node > node_data.len) return;
|
if (node == 0 or node > node_data.len) return;
|
||||||
|
|
||||||
const FrameSize = @sizeOf(@Frame(writeNodeInlayHint));
|
var allocator = arena.allocator();
|
||||||
var child_frame = try arena.child_allocator.alignedAlloc(u8, std.Target.stack_align, FrameSize);
|
|
||||||
defer arena.child_allocator.free(child_frame);
|
|
||||||
|
|
||||||
const tag = node_tags[node];
|
const tag = node_tags[node];
|
||||||
|
|
||||||
@ -283,7 +296,7 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
if (!isNodeInRange(tree, param, range)) continue;
|
if (!isNodeInRange(tree, param, range)) continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, param, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, param, range });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|
||||||
@ -314,7 +327,7 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
if (!isNodeInRange(tree, param, range)) continue;
|
if (!isNodeInRange(tree, param, range)) continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, param, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, param, range });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|
||||||
@ -336,7 +349,7 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
.array_type_sentinel => {
|
.array_type_sentinel => {
|
||||||
const array_type = tree.arrayTypeSentinel(node);
|
const array_type = tree.arrayTypeSentinel(node);
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, array_type.ast.sentinel, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, array_type.ast.sentinel, range });
|
||||||
},
|
},
|
||||||
|
|
||||||
.ptr_type_aligned,
|
.ptr_type_aligned,
|
||||||
@ -347,19 +360,19 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
const ptr_type: Ast.full.PtrType = ast.ptrType(tree, node).?;
|
const ptr_type: Ast.full.PtrType = ast.ptrType(tree, node).?;
|
||||||
|
|
||||||
if (ptr_type.ast.sentinel != 0) {
|
if (ptr_type.ast.sentinel != 0) {
|
||||||
return try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, ptr_type.ast.sentinel, range });
|
return try callWriteNodeInlayHint(allocator, .{ builder, arena, store, ptr_type.ast.sentinel, range });
|
||||||
}
|
}
|
||||||
|
|
||||||
if (ptr_type.ast.align_node != 0) {
|
if (ptr_type.ast.align_node != 0) {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, ptr_type.ast.align_node, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, ptr_type.ast.align_node, range });
|
||||||
|
|
||||||
if (ptr_type.ast.bit_range_start != 0) {
|
if (ptr_type.ast.bit_range_start != 0) {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, ptr_type.ast.bit_range_start, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, ptr_type.ast.bit_range_start, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, ptr_type.ast.bit_range_end, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, ptr_type.ast.bit_range_end, range });
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, ptr_type.ast.child_type, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, ptr_type.ast.child_type, range });
|
||||||
},
|
},
|
||||||
|
|
||||||
.@"usingnamespace",
|
.@"usingnamespace",
|
||||||
@ -379,7 +392,7 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
.grouped_expression,
|
.grouped_expression,
|
||||||
.@"comptime",
|
.@"comptime",
|
||||||
.@"nosuspend",
|
.@"nosuspend",
|
||||||
=> try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, node_data[node].lhs, range }),
|
=> try callWriteNodeInlayHint(allocator, .{ builder, arena, store, node_data[node].lhs, range }),
|
||||||
|
|
||||||
.test_decl,
|
.test_decl,
|
||||||
.global_var_decl,
|
.global_var_decl,
|
||||||
@ -389,7 +402,7 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
.@"errdefer",
|
.@"errdefer",
|
||||||
.@"defer",
|
.@"defer",
|
||||||
.@"break",
|
.@"break",
|
||||||
=> try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, node_data[node].rhs, range }),
|
=> try callWriteNodeInlayHint(allocator, .{ builder, arena, store, node_data[node].rhs, range }),
|
||||||
|
|
||||||
.@"catch",
|
.@"catch",
|
||||||
.equal_equal,
|
.equal_equal,
|
||||||
@ -444,8 +457,8 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
.error_value,
|
.error_value,
|
||||||
.error_union,
|
.error_union,
|
||||||
=> {
|
=> {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, node_data[node].lhs, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, node_data[node].lhs, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, node_data[node].rhs, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, node_data[node].rhs, range });
|
||||||
},
|
},
|
||||||
|
|
||||||
.slice_open,
|
.slice_open,
|
||||||
@ -459,10 +472,10 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
else => unreachable,
|
else => unreachable,
|
||||||
};
|
};
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, slice.ast.sliced, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, slice.ast.sliced, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, slice.ast.start, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, slice.ast.start, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, slice.ast.end, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, slice.ast.end, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, slice.ast.sentinel, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, slice.ast.sentinel, range });
|
||||||
},
|
},
|
||||||
|
|
||||||
.array_init_one,
|
.array_init_one,
|
||||||
@ -483,9 +496,9 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
else => unreachable,
|
else => unreachable,
|
||||||
};
|
};
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, array_init.ast.type_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, array_init.ast.type_expr, range });
|
||||||
for (array_init.ast.elements) |elem| {
|
for (array_init.ast.elements) |elem| {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, elem, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, elem, range });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|
||||||
@ -507,21 +520,21 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
else => unreachable,
|
else => unreachable,
|
||||||
};
|
};
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, struct_init.ast.type_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, struct_init.ast.type_expr, range });
|
||||||
|
|
||||||
for (struct_init.ast.fields) |field_init| {
|
for (struct_init.ast.fields) |field_init| {
|
||||||
if (struct_init.ast.fields.len > inlay_hints_max_inline_children) {
|
if (struct_init.ast.fields.len > inlay_hints_max_inline_children) {
|
||||||
if (!isNodeInRange(tree, field_init, range)) continue;
|
if (!isNodeInRange(tree, field_init, range)) continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, field_init, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, field_init, range });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|
||||||
.@"switch",
|
.@"switch",
|
||||||
.switch_comma,
|
.switch_comma,
|
||||||
=> {
|
=> {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, node_data[node].lhs, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, node_data[node].lhs, range });
|
||||||
|
|
||||||
const extra = tree.extraData(node_data[node].rhs, Ast.Node.SubRange);
|
const extra = tree.extraData(node_data[node].rhs, Ast.Node.SubRange);
|
||||||
const cases = tree.extra_data[extra.start..extra.end];
|
const cases = tree.extra_data[extra.start..extra.end];
|
||||||
@ -531,7 +544,7 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
if (!isNodeInRange(tree, case_node, range)) continue;
|
if (!isNodeInRange(tree, case_node, range)) continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, case_node, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, case_node, range });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|
||||||
@ -540,7 +553,7 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
=> {
|
=> {
|
||||||
const switch_case = if (tag == .switch_case) tree.switchCase(node) else tree.switchCaseOne(node);
|
const switch_case = if (tag == .switch_case) tree.switchCase(node) else tree.switchCaseOne(node);
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, switch_case.ast.target_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, switch_case.ast.target_expr, range });
|
||||||
},
|
},
|
||||||
|
|
||||||
.while_simple,
|
.while_simple,
|
||||||
@ -551,12 +564,12 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
=> {
|
=> {
|
||||||
const while_node = ast.whileAst(tree, node).?;
|
const while_node = ast.whileAst(tree, node).?;
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, while_node.ast.cond_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, while_node.ast.cond_expr, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, while_node.ast.cont_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, while_node.ast.cont_expr, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, while_node.ast.then_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, while_node.ast.then_expr, range });
|
||||||
|
|
||||||
if (while_node.ast.else_expr != 0) {
|
if (while_node.ast.else_expr != 0) {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, while_node.ast.else_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, while_node.ast.else_expr, range });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|
||||||
@ -564,9 +577,9 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
.@"if",
|
.@"if",
|
||||||
=> {
|
=> {
|
||||||
const if_node = ast.ifFull(tree, node);
|
const if_node = ast.ifFull(tree, node);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, if_node.ast.cond_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, if_node.ast.cond_expr, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, if_node.ast.then_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, if_node.ast.then_expr, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, if_node.ast.else_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, if_node.ast.else_expr, range });
|
||||||
},
|
},
|
||||||
|
|
||||||
.fn_proto_simple,
|
.fn_proto_simple,
|
||||||
@ -580,18 +593,18 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
|
|
||||||
var it = fn_proto.iterate(&tree);
|
var it = fn_proto.iterate(&tree);
|
||||||
while (ast.nextFnParam(&it)) |param_decl| {
|
while (ast.nextFnParam(&it)) |param_decl| {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, param_decl.type_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, param_decl.type_expr, range });
|
||||||
}
|
}
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, fn_proto.ast.align_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, fn_proto.ast.align_expr, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, fn_proto.ast.addrspace_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, fn_proto.ast.addrspace_expr, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, fn_proto.ast.section_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, fn_proto.ast.section_expr, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, fn_proto.ast.callconv_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, fn_proto.ast.callconv_expr, range });
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, fn_proto.ast.return_type, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, fn_proto.ast.return_type, range });
|
||||||
|
|
||||||
if (tag == .fn_decl) {
|
if (tag == .fn_decl) {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, node_data[node].rhs, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, node_data[node].rhs, range });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|
||||||
@ -611,14 +624,14 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
var buffer: [2]Ast.Node.Index = undefined;
|
var buffer: [2]Ast.Node.Index = undefined;
|
||||||
const decl: Ast.full.ContainerDecl = ast.containerDecl(tree, node, &buffer).?;
|
const decl: Ast.full.ContainerDecl = ast.containerDecl(tree, node, &buffer).?;
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, decl.ast.arg, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, decl.ast.arg, range });
|
||||||
|
|
||||||
for (decl.ast.members) |child| {
|
for (decl.ast.members) |child| {
|
||||||
if (decl.ast.members.len > inlay_hints_max_inline_children) {
|
if (decl.ast.members.len > inlay_hints_max_inline_children) {
|
||||||
if (!isNodeInRange(tree, child, range)) continue;
|
if (!isNodeInRange(tree, child, range)) continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, child, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, child, range });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|
||||||
@ -628,15 +641,15 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
=> {
|
=> {
|
||||||
const container_field = ast.containerField(tree, node).?;
|
const container_field = ast.containerField(tree, node).?;
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, container_field.ast.value_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, container_field.ast.value_expr, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, container_field.ast.align_expr, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, container_field.ast.align_expr, range });
|
||||||
},
|
},
|
||||||
|
|
||||||
.block_two,
|
.block_two,
|
||||||
.block_two_semicolon,
|
.block_two_semicolon,
|
||||||
=> {
|
=> {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, node_data[node].lhs, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, node_data[node].lhs, range });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, node_data[node].rhs, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, node_data[node].rhs, range });
|
||||||
},
|
},
|
||||||
|
|
||||||
.block,
|
.block,
|
||||||
@ -649,7 +662,7 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
if (!isNodeInRange(tree, child, range)) continue;
|
if (!isNodeInRange(tree, child, range)) continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, child, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, child, range });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|
||||||
@ -664,7 +677,7 @@ fn writeNodeInlayHint(builder: *Builder, arena: *std.heap.ArenaAllocator, store:
|
|||||||
else => return,
|
else => return,
|
||||||
};
|
};
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeInlayHint, .{ builder, arena, store, asm_node.ast.template, range });
|
try callWriteNodeInlayHint(allocator, .{ builder, arena, store, asm_node.ast.template, range });
|
||||||
},
|
},
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1,4 +1,5 @@
|
|||||||
const std = @import("std");
|
const std = @import("std");
|
||||||
|
const zig_builtin = @import("builtin");
|
||||||
const offsets = @import("offsets.zig");
|
const offsets = @import("offsets.zig");
|
||||||
const DocumentStore = @import("DocumentStore.zig");
|
const DocumentStore = @import("DocumentStore.zig");
|
||||||
const analysis = @import("analysis.zig");
|
const analysis = @import("analysis.zig");
|
||||||
@ -50,16 +51,18 @@ pub const TokenModifiers = packed struct {
|
|||||||
};
|
};
|
||||||
|
|
||||||
const Builder = struct {
|
const Builder = struct {
|
||||||
allocator: std.mem.Allocator,
|
arena: *std.heap.ArenaAllocator,
|
||||||
|
store: *DocumentStore,
|
||||||
handle: *DocumentStore.Handle,
|
handle: *DocumentStore.Handle,
|
||||||
previous_position: usize = 0,
|
previous_position: usize = 0,
|
||||||
previous_token: ?Ast.TokenIndex = null,
|
previous_token: ?Ast.TokenIndex = null,
|
||||||
arr: std.ArrayListUnmanaged(u32),
|
arr: std.ArrayListUnmanaged(u32),
|
||||||
encoding: offsets.Encoding,
|
encoding: offsets.Encoding,
|
||||||
|
|
||||||
fn init(allocator: std.mem.Allocator, handle: *DocumentStore.Handle, encoding: offsets.Encoding) Builder {
|
fn init(arena: *std.heap.ArenaAllocator, store: *DocumentStore, handle: *DocumentStore.Handle, encoding: offsets.Encoding) Builder {
|
||||||
return Builder{
|
return Builder{
|
||||||
.allocator = allocator,
|
.arena = arena,
|
||||||
|
.store = store,
|
||||||
.handle = handle,
|
.handle = handle,
|
||||||
.arr = std.ArrayListUnmanaged(u32){},
|
.arr = std.ArrayListUnmanaged(u32){},
|
||||||
.encoding = encoding,
|
.encoding = encoding,
|
||||||
@ -182,7 +185,7 @@ const Builder = struct {
|
|||||||
const text = self.handle.tree.source[self.previous_position..start];
|
const text = self.handle.tree.source[self.previous_position..start];
|
||||||
const delta = offsets.indexToPosition(text, text.len, self.encoding);
|
const delta = offsets.indexToPosition(text, text.len, self.encoding);
|
||||||
|
|
||||||
try self.arr.appendSlice(self.allocator, &.{
|
try self.arr.appendSlice(self.arena.allocator(), &.{
|
||||||
@truncate(u32, delta.line),
|
@truncate(u32, delta.line),
|
||||||
@truncate(u32, delta.character),
|
@truncate(u32, delta.character),
|
||||||
@truncate(u32, length),
|
@truncate(u32, length),
|
||||||
@ -193,7 +196,7 @@ const Builder = struct {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn toOwnedSlice(self: *Builder) []u32 {
|
fn toOwnedSlice(self: *Builder) []u32 {
|
||||||
return self.arr.toOwnedSlice(self.allocator);
|
return self.arr.toOwnedSlice(self.arena.allocator());
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
@ -260,16 +263,24 @@ fn colorIdentifierBasedOnType(builder: *Builder, type_node: analysis.TypeWithHan
|
|||||||
|
|
||||||
const WriteTokensError = error{
|
const WriteTokensError = error{
|
||||||
OutOfMemory,
|
OutOfMemory,
|
||||||
Utf8InvalidStartByte,
|
|
||||||
CodepointTooLong,
|
|
||||||
Utf8ExpectedContinuation,
|
|
||||||
Utf8OverlongEncoding,
|
|
||||||
Utf8EncodesSurrogateHalf,
|
|
||||||
Utf8CodepointTooLarge,
|
|
||||||
MovedBackwards,
|
MovedBackwards,
|
||||||
};
|
};
|
||||||
|
|
||||||
fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *DocumentStore, maybe_node: ?Ast.Node.Index) WriteTokensError!void {
|
/// HACK self-hosted has not implemented async yet
|
||||||
|
fn callWriteNodeTokens(allocator: std.mem.Allocator, args: anytype) WriteTokensError!void {
|
||||||
|
if (zig_builtin.zig_backend == .other or zig_builtin.zig_backend == .stage1) {
|
||||||
|
const FrameSize = @sizeOf(@Frame(writeNodeTokens));
|
||||||
|
var child_frame = try allocator.alignedAlloc(u8, std.Target.stack_align, FrameSize);
|
||||||
|
// defer allocator.free(child_frame); allocator is a arena allocator
|
||||||
|
|
||||||
|
return await @asyncCall(child_frame, {}, writeNodeTokens, args);
|
||||||
|
} else {
|
||||||
|
// TODO find a non recursive solution
|
||||||
|
return @call(.{}, writeNodeTokens, args);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn writeNodeTokens(builder: *Builder, maybe_node: ?Ast.Node.Index) WriteTokensError!void {
|
||||||
const node = maybe_node orelse return;
|
const node = maybe_node orelse return;
|
||||||
|
|
||||||
const handle = builder.handle;
|
const handle = builder.handle;
|
||||||
@ -280,9 +291,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
const main_tokens = tree.nodes.items(.main_token);
|
const main_tokens = tree.nodes.items(.main_token);
|
||||||
if (node == 0 or node > node_data.len) return;
|
if (node == 0 or node > node_data.len) return;
|
||||||
|
|
||||||
const FrameSize = @sizeOf(@Frame(writeNodeTokens));
|
var allocator = builder.arena.allocator();
|
||||||
var child_frame = try arena.child_allocator.alignedAlloc(u8, std.Target.stack_align, FrameSize);
|
|
||||||
defer arena.child_allocator.free(child_frame);
|
|
||||||
|
|
||||||
const tag = node_tags[node];
|
const tag = node_tags[node];
|
||||||
const main_token = main_tokens[node];
|
const main_token = main_tokens[node];
|
||||||
@ -292,7 +301,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
.container_field,
|
.container_field,
|
||||||
.container_field_align,
|
.container_field_align,
|
||||||
.container_field_init,
|
.container_field_init,
|
||||||
=> try writeContainerField(builder, arena, store, node, .field, child_frame),
|
=> try writeContainerField(builder, node, .field),
|
||||||
.@"errdefer" => {
|
.@"errdefer" => {
|
||||||
try writeToken(builder, main_token, .keyword);
|
try writeToken(builder, main_token, .keyword);
|
||||||
|
|
||||||
@ -303,7 +312,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeToken(builder, payload_tok + 1, .operator);
|
try writeToken(builder, payload_tok + 1, .operator);
|
||||||
}
|
}
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].rhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].rhs });
|
||||||
},
|
},
|
||||||
.block,
|
.block,
|
||||||
.block_semicolon,
|
.block_semicolon,
|
||||||
@ -319,9 +328,9 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
|
|
||||||
for (statements) |child| {
|
for (statements) |child| {
|
||||||
if (node_tags[child].isContainerField()) {
|
if (node_tags[child].isContainerField()) {
|
||||||
try writeContainerField(builder, arena, store, child, .field, child_frame);
|
try writeContainerField(builder, child, .field);
|
||||||
} else {
|
} else {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, child });
|
try callWriteNodeTokens(allocator, .{ builder, child });
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
@ -340,18 +349,18 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeToken(builder, var_decl.comptime_token, .keyword);
|
try writeToken(builder, var_decl.comptime_token, .keyword);
|
||||||
try writeToken(builder, var_decl.ast.mut_token, .keyword);
|
try writeToken(builder, var_decl.ast.mut_token, .keyword);
|
||||||
|
|
||||||
if (try analysis.resolveTypeOfNode(store, arena, .{ .node = node, .handle = handle })) |decl_type| {
|
if (try analysis.resolveTypeOfNode(builder.store, builder.arena, .{ .node = node, .handle = handle })) |decl_type| {
|
||||||
try colorIdentifierBasedOnType(builder, decl_type, var_decl.ast.mut_token + 1, .{ .declaration = true });
|
try colorIdentifierBasedOnType(builder, decl_type, var_decl.ast.mut_token + 1, .{ .declaration = true });
|
||||||
} else {
|
} else {
|
||||||
try writeTokenMod(builder, var_decl.ast.mut_token + 1, .variable, .{ .declaration = true });
|
try writeTokenMod(builder, var_decl.ast.mut_token + 1, .variable, .{ .declaration = true });
|
||||||
}
|
}
|
||||||
try writeToken(builder, var_decl.ast.mut_token + 2, .operator);
|
try writeToken(builder, var_decl.ast.mut_token + 2, .operator);
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, var_decl.ast.type_node });
|
try callWriteNodeTokens(allocator, .{ builder, var_decl.ast.type_node });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, var_decl.ast.align_node });
|
try callWriteNodeTokens(allocator, .{ builder, var_decl.ast.align_node });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, var_decl.ast.section_node });
|
try callWriteNodeTokens(allocator, .{ builder, var_decl.ast.section_node });
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, var_decl.ast.init_node });
|
try callWriteNodeTokens(allocator, .{ builder, var_decl.ast.init_node });
|
||||||
},
|
},
|
||||||
.@"usingnamespace" => {
|
.@"usingnamespace" => {
|
||||||
const first_tok = tree.firstToken(node);
|
const first_tok = tree.firstToken(node);
|
||||||
@ -359,7 +368,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeDocComments(builder, tree, first_tok - 1);
|
try writeDocComments(builder, tree, first_tok - 1);
|
||||||
try writeToken(builder, if (token_tags[first_tok] == .keyword_pub) first_tok else null, .keyword);
|
try writeToken(builder, if (token_tags[first_tok] == .keyword_pub) first_tok else null, .keyword);
|
||||||
try writeToken(builder, main_token, .keyword);
|
try writeToken(builder, main_token, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
},
|
},
|
||||||
.container_decl,
|
.container_decl,
|
||||||
.container_decl_trailing,
|
.container_decl_trailing,
|
||||||
@ -381,17 +390,17 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeToken(builder, decl.ast.main_token, .keyword);
|
try writeToken(builder, decl.ast.main_token, .keyword);
|
||||||
if (decl.ast.enum_token) |enum_token| {
|
if (decl.ast.enum_token) |enum_token| {
|
||||||
if (decl.ast.arg != 0)
|
if (decl.ast.arg != 0)
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, decl.ast.arg })
|
try callWriteNodeTokens(allocator, .{ builder, decl.ast.arg })
|
||||||
else
|
else
|
||||||
try writeToken(builder, enum_token, .keyword);
|
try writeToken(builder, enum_token, .keyword);
|
||||||
} else try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, decl.ast.arg });
|
} else try callWriteNodeTokens(allocator, .{ builder, decl.ast.arg });
|
||||||
|
|
||||||
const field_token_type = fieldTokenType(node, handle);
|
const field_token_type = fieldTokenType(node, handle);
|
||||||
for (decl.ast.members) |child| {
|
for (decl.ast.members) |child| {
|
||||||
if (node_tags[child].isContainerField()) {
|
if (node_tags[child].isContainerField()) {
|
||||||
try writeContainerField(builder, arena, store, child, field_token_type, child_frame);
|
try writeContainerField(builder, child, field_token_type);
|
||||||
} else {
|
} else {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, child });
|
try callWriteNodeTokens(allocator, .{ builder, child });
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
@ -411,8 +420,8 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
}
|
}
|
||||||
|
|
||||||
if (try analysis.lookupSymbolGlobal(
|
if (try analysis.lookupSymbolGlobal(
|
||||||
store,
|
builder.store,
|
||||||
arena,
|
builder.arena,
|
||||||
handle,
|
handle,
|
||||||
name,
|
name,
|
||||||
tree.tokens.items(.start)[main_token],
|
tree.tokens.items(.start)[main_token],
|
||||||
@ -421,7 +430,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
return try writeToken(builder, main_token, .parameter);
|
return try writeToken(builder, main_token, .parameter);
|
||||||
}
|
}
|
||||||
var bound_type_params = analysis.BoundTypeParams{};
|
var bound_type_params = analysis.BoundTypeParams{};
|
||||||
if (try child.resolveType(store, arena, &bound_type_params)) |decl_type| {
|
if (try child.resolveType(builder.store, builder.arena, &bound_type_params)) |decl_type| {
|
||||||
try colorIdentifierBasedOnType(builder, decl_type, main_token, .{});
|
try colorIdentifierBasedOnType(builder, decl_type, main_token, .{});
|
||||||
} else {
|
} else {
|
||||||
try writeTokenMod(builder, main_token, .variable, .{});
|
try writeTokenMod(builder, main_token, .variable, .{});
|
||||||
@ -464,28 +473,28 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeTokenMod(builder, param_decl.name_token, .parameter, .{ .declaration = true });
|
try writeTokenMod(builder, param_decl.name_token, .parameter, .{ .declaration = true });
|
||||||
if (param_decl.anytype_ellipsis3) |any_token| {
|
if (param_decl.anytype_ellipsis3) |any_token| {
|
||||||
try writeToken(builder, any_token, .type);
|
try writeToken(builder, any_token, .type);
|
||||||
} else try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, param_decl.type_expr });
|
} else try callWriteNodeTokens(allocator, .{ builder, param_decl.type_expr });
|
||||||
}
|
}
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, fn_proto.ast.align_expr });
|
try callWriteNodeTokens(allocator, .{ builder, fn_proto.ast.align_expr });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, fn_proto.ast.section_expr });
|
try callWriteNodeTokens(allocator, .{ builder, fn_proto.ast.section_expr });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, fn_proto.ast.callconv_expr });
|
try callWriteNodeTokens(allocator, .{ builder, fn_proto.ast.callconv_expr });
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, fn_proto.ast.return_type });
|
try callWriteNodeTokens(allocator, .{ builder, fn_proto.ast.return_type });
|
||||||
|
|
||||||
if (tag == .fn_decl)
|
if (tag == .fn_decl)
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].rhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].rhs });
|
||||||
},
|
},
|
||||||
.anyframe_type => {
|
.anyframe_type => {
|
||||||
try writeToken(builder, main_token, .type);
|
try writeToken(builder, main_token, .type);
|
||||||
if (node_data[node].rhs != 0) {
|
if (node_data[node].rhs != 0) {
|
||||||
try writeToken(builder, node_data[node].lhs, .type);
|
try writeToken(builder, node_data[node].lhs, .type);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].rhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].rhs });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
.@"defer" => {
|
.@"defer" => {
|
||||||
try writeToken(builder, main_token, .keyword);
|
try writeToken(builder, main_token, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].rhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].rhs });
|
||||||
},
|
},
|
||||||
.@"comptime",
|
.@"comptime",
|
||||||
.@"nosuspend",
|
.@"nosuspend",
|
||||||
@ -493,25 +502,25 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
if (analysis.getDocCommentTokenIndex(token_tags, main_token)) |doc|
|
if (analysis.getDocCommentTokenIndex(token_tags, main_token)) |doc|
|
||||||
try writeDocComments(builder, tree, doc);
|
try writeDocComments(builder, tree, doc);
|
||||||
try writeToken(builder, main_token, .keyword);
|
try writeToken(builder, main_token, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
},
|
},
|
||||||
.@"switch",
|
.@"switch",
|
||||||
.switch_comma,
|
.switch_comma,
|
||||||
=> {
|
=> {
|
||||||
try writeToken(builder, main_token, .keyword);
|
try writeToken(builder, main_token, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
const extra = tree.extraData(node_data[node].rhs, Ast.Node.SubRange);
|
const extra = tree.extraData(node_data[node].rhs, Ast.Node.SubRange);
|
||||||
const cases = tree.extra_data[extra.start..extra.end];
|
const cases = tree.extra_data[extra.start..extra.end];
|
||||||
|
|
||||||
for (cases) |case_node| {
|
for (cases) |case_node| {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, case_node });
|
try callWriteNodeTokens(allocator, .{ builder, case_node });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
.switch_case_one,
|
.switch_case_one,
|
||||||
.switch_case,
|
.switch_case,
|
||||||
=> {
|
=> {
|
||||||
const switch_case = if (tag == .switch_case) tree.switchCase(node) else tree.switchCaseOne(node);
|
const switch_case = if (tag == .switch_case) tree.switchCase(node) else tree.switchCaseOne(node);
|
||||||
for (switch_case.ast.values) |item_node| try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, item_node });
|
for (switch_case.ast.values) |item_node| try callWriteNodeTokens(allocator, .{ builder, item_node });
|
||||||
// check it it's 'else'
|
// check it it's 'else'
|
||||||
if (switch_case.ast.values.len == 0) try writeToken(builder, switch_case.ast.arrow_token - 1, .keyword);
|
if (switch_case.ast.values.len == 0) try writeToken(builder, switch_case.ast.arrow_token - 1, .keyword);
|
||||||
try writeToken(builder, switch_case.ast.arrow_token, .operator);
|
try writeToken(builder, switch_case.ast.arrow_token, .operator);
|
||||||
@ -519,7 +528,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
const actual_payload = payload_token + @boolToInt(token_tags[payload_token] == .asterisk);
|
const actual_payload = payload_token + @boolToInt(token_tags[payload_token] == .asterisk);
|
||||||
try writeToken(builder, actual_payload, .variable);
|
try writeToken(builder, actual_payload, .variable);
|
||||||
}
|
}
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, switch_case.ast.target_expr });
|
try callWriteNodeTokens(allocator, .{ builder, switch_case.ast.target_expr });
|
||||||
},
|
},
|
||||||
.@"while",
|
.@"while",
|
||||||
.while_simple,
|
.while_simple,
|
||||||
@ -531,7 +540,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeToken(builder, while_node.label_token, .label);
|
try writeToken(builder, while_node.label_token, .label);
|
||||||
try writeToken(builder, while_node.inline_token, .keyword);
|
try writeToken(builder, while_node.inline_token, .keyword);
|
||||||
try writeToken(builder, while_node.ast.while_token, .keyword);
|
try writeToken(builder, while_node.ast.while_token, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, while_node.ast.cond_expr });
|
try callWriteNodeTokens(allocator, .{ builder, while_node.ast.cond_expr });
|
||||||
if (while_node.payload_token) |payload| {
|
if (while_node.payload_token) |payload| {
|
||||||
try writeToken(builder, payload - 1, .operator);
|
try writeToken(builder, payload - 1, .operator);
|
||||||
try writeToken(builder, payload, .variable);
|
try writeToken(builder, payload, .variable);
|
||||||
@ -543,9 +552,9 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
}
|
}
|
||||||
try writeToken(builder, r_pipe, .operator);
|
try writeToken(builder, r_pipe, .operator);
|
||||||
}
|
}
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, while_node.ast.cont_expr });
|
try callWriteNodeTokens(allocator, .{ builder, while_node.ast.cont_expr });
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, while_node.ast.then_expr });
|
try callWriteNodeTokens(allocator, .{ builder, while_node.ast.then_expr });
|
||||||
|
|
||||||
if (while_node.ast.else_expr != 0) {
|
if (while_node.ast.else_expr != 0) {
|
||||||
try writeToken(builder, while_node.else_token, .keyword);
|
try writeToken(builder, while_node.else_token, .keyword);
|
||||||
@ -555,7 +564,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeToken(builder, err_token, .variable);
|
try writeToken(builder, err_token, .variable);
|
||||||
try writeToken(builder, err_token + 1, .operator);
|
try writeToken(builder, err_token + 1, .operator);
|
||||||
}
|
}
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, while_node.ast.else_expr });
|
try callWriteNodeTokens(allocator, .{ builder, while_node.ast.else_expr });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
.@"if",
|
.@"if",
|
||||||
@ -564,7 +573,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
const if_node = ast.ifFull(tree, node);
|
const if_node = ast.ifFull(tree, node);
|
||||||
|
|
||||||
try writeToken(builder, if_node.ast.if_token, .keyword);
|
try writeToken(builder, if_node.ast.if_token, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, if_node.ast.cond_expr });
|
try callWriteNodeTokens(allocator, .{ builder, if_node.ast.cond_expr });
|
||||||
|
|
||||||
if (if_node.payload_token) |payload| {
|
if (if_node.payload_token) |payload| {
|
||||||
// if (?x) |x|
|
// if (?x) |x|
|
||||||
@ -572,7 +581,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeToken(builder, payload, .variable); // x
|
try writeToken(builder, payload, .variable); // x
|
||||||
try writeToken(builder, payload + 1, .operator); // |
|
try writeToken(builder, payload + 1, .operator); // |
|
||||||
}
|
}
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, if_node.ast.then_expr });
|
try callWriteNodeTokens(allocator, .{ builder, if_node.ast.then_expr });
|
||||||
|
|
||||||
if (if_node.ast.else_expr != 0) {
|
if (if_node.ast.else_expr != 0) {
|
||||||
try writeToken(builder, if_node.else_token, .keyword);
|
try writeToken(builder, if_node.else_token, .keyword);
|
||||||
@ -582,7 +591,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeToken(builder, err_token, .variable); // err
|
try writeToken(builder, err_token, .variable); // err
|
||||||
try writeToken(builder, err_token + 1, .operator); // |
|
try writeToken(builder, err_token + 1, .operator); // |
|
||||||
}
|
}
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, if_node.ast.else_expr });
|
try callWriteNodeTokens(allocator, .{ builder, if_node.ast.else_expr });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
.array_init,
|
.array_init,
|
||||||
@ -603,8 +612,8 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
else => unreachable,
|
else => unreachable,
|
||||||
};
|
};
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, array_init.ast.type_expr });
|
try callWriteNodeTokens(allocator, .{ builder, array_init.ast.type_expr });
|
||||||
for (array_init.ast.elements) |elem| try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, elem });
|
for (array_init.ast.elements) |elem| try callWriteNodeTokens(allocator, .{ builder, elem });
|
||||||
},
|
},
|
||||||
.struct_init,
|
.struct_init,
|
||||||
.struct_init_comma,
|
.struct_init_comma,
|
||||||
@ -627,12 +636,13 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
var field_token_type: ?TokenType = null;
|
var field_token_type: ?TokenType = null;
|
||||||
|
|
||||||
if (struct_init.ast.type_expr != 0) {
|
if (struct_init.ast.type_expr != 0) {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, struct_init.ast.type_expr });
|
try callWriteNodeTokens(allocator, .{ builder, struct_init.ast.type_expr });
|
||||||
|
|
||||||
field_token_type = if (try analysis.resolveTypeOfNode(store, arena, .{
|
field_token_type = if (try analysis.resolveTypeOfNode(
|
||||||
.node = struct_init.ast.type_expr,
|
builder.store,
|
||||||
.handle = handle,
|
builder.arena,
|
||||||
})) |struct_type| switch (struct_type.type.data) {
|
.{ .node = struct_init.ast.type_expr, .handle = handle },
|
||||||
|
)) |struct_type| switch (struct_type.type.data) {
|
||||||
.other => |type_node| if (ast.isContainer(struct_type.handle.tree, type_node))
|
.other => |type_node| if (ast.isContainer(struct_type.handle.tree, type_node))
|
||||||
fieldTokenType(type_node, struct_type.handle)
|
fieldTokenType(type_node, struct_type.handle)
|
||||||
else
|
else
|
||||||
@ -646,7 +656,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeToken(builder, init_token - 3, field_token_type orelse .field); // '.'
|
try writeToken(builder, init_token - 3, field_token_type orelse .field); // '.'
|
||||||
try writeToken(builder, init_token - 2, field_token_type orelse .field); // name
|
try writeToken(builder, init_token - 2, field_token_type orelse .field); // name
|
||||||
try writeToken(builder, init_token - 1, .operator); // '='
|
try writeToken(builder, init_token - 1, .operator); // '='
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, field_init });
|
try callWriteNodeTokens(allocator, .{ builder, field_init });
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
.call,
|
.call,
|
||||||
@ -662,14 +672,14 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
const call = ast.callFull(tree, node, ¶ms).?;
|
const call = ast.callFull(tree, node, ¶ms).?;
|
||||||
|
|
||||||
try writeToken(builder, call.async_token, .keyword);
|
try writeToken(builder, call.async_token, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, call.ast.fn_expr });
|
try callWriteNodeTokens(allocator, .{ builder, call.ast.fn_expr });
|
||||||
|
|
||||||
if (builder.previous_token) |prev| {
|
if (builder.previous_token) |prev| {
|
||||||
if (prev != ast.lastToken(tree, call.ast.fn_expr) and token_tags[ast.lastToken(tree, call.ast.fn_expr)] == .identifier) {
|
if (prev != ast.lastToken(tree, call.ast.fn_expr) and token_tags[ast.lastToken(tree, call.ast.fn_expr)] == .identifier) {
|
||||||
try writeToken(builder, ast.lastToken(tree, call.ast.fn_expr), .function);
|
try writeToken(builder, ast.lastToken(tree, call.ast.fn_expr), .function);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
for (call.ast.params) |param| try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, param });
|
for (call.ast.params) |param| try callWriteNodeTokens(allocator, .{ builder, param });
|
||||||
},
|
},
|
||||||
.slice,
|
.slice,
|
||||||
.slice_open,
|
.slice_open,
|
||||||
@ -682,27 +692,27 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
else => unreachable,
|
else => unreachable,
|
||||||
};
|
};
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, slice.ast.sliced });
|
try callWriteNodeTokens(allocator, .{ builder, slice.ast.sliced });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, slice.ast.start });
|
try callWriteNodeTokens(allocator, .{ builder, slice.ast.start });
|
||||||
try writeToken(builder, ast.lastToken(tree, slice.ast.start) + 1, .operator);
|
try writeToken(builder, ast.lastToken(tree, slice.ast.start) + 1, .operator);
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, slice.ast.end });
|
try callWriteNodeTokens(allocator, .{ builder, slice.ast.end });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, slice.ast.sentinel });
|
try callWriteNodeTokens(allocator, .{ builder, slice.ast.sentinel });
|
||||||
},
|
},
|
||||||
.array_access => {
|
.array_access => {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].rhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].rhs });
|
||||||
},
|
},
|
||||||
.deref => {
|
.deref => {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
try writeToken(builder, main_token, .operator);
|
try writeToken(builder, main_token, .operator);
|
||||||
},
|
},
|
||||||
.unwrap_optional => {
|
.unwrap_optional => {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
try writeToken(builder, main_token + 1, .operator);
|
try writeToken(builder, main_token + 1, .operator);
|
||||||
},
|
},
|
||||||
.grouped_expression => {
|
.grouped_expression => {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
},
|
},
|
||||||
.@"break",
|
.@"break",
|
||||||
.@"continue",
|
.@"continue",
|
||||||
@ -710,11 +720,11 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
try writeToken(builder, main_token, .keyword);
|
try writeToken(builder, main_token, .keyword);
|
||||||
if (node_data[node].lhs != 0)
|
if (node_data[node].lhs != 0)
|
||||||
try writeToken(builder, node_data[node].lhs, .label);
|
try writeToken(builder, node_data[node].lhs, .label);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].rhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].rhs });
|
||||||
},
|
},
|
||||||
.@"suspend", .@"return" => {
|
.@"suspend", .@"return" => {
|
||||||
try writeToken(builder, main_token, .keyword);
|
try writeToken(builder, main_token, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
},
|
},
|
||||||
.number_literal => {
|
.number_literal => {
|
||||||
try writeToken(builder, main_token, .number);
|
try writeToken(builder, main_token, .number);
|
||||||
@ -733,7 +743,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
|
|
||||||
try writeToken(builder, main_token, .builtin);
|
try writeToken(builder, main_token, .builtin);
|
||||||
for (params) |param|
|
for (params) |param|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, param });
|
try callWriteNodeTokens(allocator, .{ builder, param });
|
||||||
},
|
},
|
||||||
.string_literal,
|
.string_literal,
|
||||||
.char_literal,
|
.char_literal,
|
||||||
@ -765,7 +775,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
|
|
||||||
try writeToken(builder, main_token, .keyword);
|
try writeToken(builder, main_token, .keyword);
|
||||||
try writeToken(builder, asm_node.volatile_token, .keyword);
|
try writeToken(builder, asm_node.volatile_token, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, asm_node.ast.template });
|
try callWriteNodeTokens(allocator, .{ builder, asm_node.ast.template });
|
||||||
// TODO Inputs, outputs.
|
// TODO Inputs, outputs.
|
||||||
},
|
},
|
||||||
.test_decl => {
|
.test_decl => {
|
||||||
@ -776,14 +786,14 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
if (token_tags[main_token + 1] == .string_literal)
|
if (token_tags[main_token + 1] == .string_literal)
|
||||||
try writeToken(builder, main_token + 1, .string);
|
try writeToken(builder, main_token + 1, .string);
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].rhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].rhs });
|
||||||
},
|
},
|
||||||
.@"catch" => {
|
.@"catch" => {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
try writeToken(builder, main_token, .keyword);
|
try writeToken(builder, main_token, .keyword);
|
||||||
if (token_tags[main_token + 1] == .pipe)
|
if (token_tags[main_token + 1] == .pipe)
|
||||||
try writeToken(builder, main_token + 1, .variable);
|
try writeToken(builder, main_token + 1, .variable);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].rhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].rhs });
|
||||||
},
|
},
|
||||||
.add,
|
.add,
|
||||||
.add_wrap,
|
.add_wrap,
|
||||||
@ -835,43 +845,48 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
.sub_sat,
|
.sub_sat,
|
||||||
.@"orelse",
|
.@"orelse",
|
||||||
=> {
|
=> {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
const token_type: TokenType = switch (tag) {
|
const token_type: TokenType = switch (tag) {
|
||||||
.bool_and, .bool_or, .@"orelse" => .keyword,
|
.bool_and, .bool_or, .@"orelse" => .keyword,
|
||||||
else => .operator,
|
else => .operator,
|
||||||
};
|
};
|
||||||
|
|
||||||
try writeToken(builder, main_token, token_type);
|
try writeToken(builder, main_token, token_type);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].rhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].rhs });
|
||||||
},
|
},
|
||||||
.field_access => {
|
.field_access => {
|
||||||
const data = node_data[node];
|
const data = node_data[node];
|
||||||
if (data.rhs == 0) return;
|
if (data.rhs == 0) return;
|
||||||
const rhs_str = ast.tokenSlice(tree, data.rhs) catch return;
|
const rhs_str = ast.tokenSlice(tree, data.rhs) catch return;
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, data.lhs });
|
try callWriteNodeTokens(allocator, .{ builder, data.lhs });
|
||||||
|
|
||||||
// TODO This is basically exactly the same as what is done in analysis.resolveTypeOfNode, with the added
|
// TODO This is basically exactly the same as what is done in analysis.resolveTypeOfNode, with the added
|
||||||
// writeToken code.
|
// writeToken code.
|
||||||
// Maybe we can hook into it insead? Also applies to Identifier and VarDecl
|
// Maybe we can hook into it insead? Also applies to Identifier and VarDecl
|
||||||
var bound_type_params = analysis.BoundTypeParams{};
|
var bound_type_params = analysis.BoundTypeParams{};
|
||||||
const lhs_type = try analysis.resolveFieldAccessLhsType(
|
const lhs_type = try analysis.resolveFieldAccessLhsType(
|
||||||
store,
|
builder.store,
|
||||||
arena,
|
builder.arena,
|
||||||
(try analysis.resolveTypeOfNodeInternal(store, arena, .{
|
(try analysis.resolveTypeOfNodeInternal(
|
||||||
.node = data.lhs,
|
builder.store,
|
||||||
.handle = handle,
|
builder.arena,
|
||||||
}, &bound_type_params)) orelse return,
|
.{ .node = data.lhs, .handle = handle },
|
||||||
|
&bound_type_params,
|
||||||
|
)) orelse return,
|
||||||
&bound_type_params,
|
&bound_type_params,
|
||||||
);
|
);
|
||||||
const left_type_node = switch (lhs_type.type.data) {
|
const left_type_node = switch (lhs_type.type.data) {
|
||||||
.other => |n| n,
|
.other => |n| n,
|
||||||
else => return,
|
else => return,
|
||||||
};
|
};
|
||||||
if (try analysis.lookupSymbolContainer(store, arena, .{
|
if (try analysis.lookupSymbolContainer(
|
||||||
.node = left_type_node,
|
builder.store,
|
||||||
.handle = lhs_type.handle,
|
builder.arena,
|
||||||
}, rhs_str, !lhs_type.type.is_type_val)) |decl_type| {
|
.{ .node = left_type_node, .handle = lhs_type.handle },
|
||||||
|
rhs_str,
|
||||||
|
!lhs_type.type.is_type_val,
|
||||||
|
)) |decl_type| {
|
||||||
switch (decl_type.decl.*) {
|
switch (decl_type.decl.*) {
|
||||||
.ast_node => |decl_node| {
|
.ast_node => |decl_node| {
|
||||||
if (decl_type.handle.tree.nodes.items(.tag)[decl_node].isContainerField()) {
|
if (decl_type.handle.tree.nodes.items(.tag)[decl_node].isContainerField()) {
|
||||||
@ -891,7 +906,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
else => {},
|
else => {},
|
||||||
}
|
}
|
||||||
|
|
||||||
if (try decl_type.resolveType(store, arena, &bound_type_params)) |resolved_type| {
|
if (try decl_type.resolveType(builder.store, builder.arena, &bound_type_params)) |resolved_type| {
|
||||||
try colorIdentifierBasedOnType(builder, resolved_type, data.rhs, .{});
|
try colorIdentifierBasedOnType(builder, resolved_type, data.rhs, .{});
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -906,12 +921,12 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
if (ptr_type.size == .One and token_tags[main_token] == .asterisk_asterisk and
|
if (ptr_type.size == .One and token_tags[main_token] == .asterisk_asterisk and
|
||||||
main_token == main_tokens[ptr_type.ast.child_type])
|
main_token == main_tokens[ptr_type.ast.child_type])
|
||||||
{
|
{
|
||||||
return try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, ptr_type.ast.child_type });
|
return try callWriteNodeTokens(allocator, .{ builder, ptr_type.ast.child_type });
|
||||||
}
|
}
|
||||||
|
|
||||||
if (ptr_type.size == .One) try writeToken(builder, main_token, .operator);
|
if (ptr_type.size == .One) try writeToken(builder, main_token, .operator);
|
||||||
if (ptr_type.ast.sentinel != 0) {
|
if (ptr_type.ast.sentinel != 0) {
|
||||||
return try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, ptr_type.ast.sentinel });
|
return try callWriteNodeTokens(allocator, .{ builder, ptr_type.ast.sentinel });
|
||||||
}
|
}
|
||||||
|
|
||||||
try writeToken(builder, ptr_type.allowzero_token, .keyword);
|
try writeToken(builder, ptr_type.allowzero_token, .keyword);
|
||||||
@ -919,19 +934,19 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
if (ptr_type.ast.align_node != 0) {
|
if (ptr_type.ast.align_node != 0) {
|
||||||
const first_tok = tree.firstToken(ptr_type.ast.align_node);
|
const first_tok = tree.firstToken(ptr_type.ast.align_node);
|
||||||
try writeToken(builder, first_tok - 2, .keyword);
|
try writeToken(builder, first_tok - 2, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, ptr_type.ast.align_node });
|
try callWriteNodeTokens(allocator, .{ builder, ptr_type.ast.align_node });
|
||||||
|
|
||||||
if (ptr_type.ast.bit_range_start != 0) {
|
if (ptr_type.ast.bit_range_start != 0) {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, ptr_type.ast.bit_range_start });
|
try callWriteNodeTokens(allocator, .{ builder, ptr_type.ast.bit_range_start });
|
||||||
try writeToken(builder, tree.firstToken(ptr_type.ast.bit_range_end - 1), .operator);
|
try writeToken(builder, tree.firstToken(ptr_type.ast.bit_range_end - 1), .operator);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, ptr_type.ast.bit_range_end });
|
try callWriteNodeTokens(allocator, .{ builder, ptr_type.ast.bit_range_end });
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
try writeToken(builder, ptr_type.const_token, .keyword);
|
try writeToken(builder, ptr_type.const_token, .keyword);
|
||||||
try writeToken(builder, ptr_type.volatile_token, .keyword);
|
try writeToken(builder, ptr_type.volatile_token, .keyword);
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, ptr_type.ast.child_type });
|
try callWriteNodeTokens(allocator, .{ builder, ptr_type.ast.child_type });
|
||||||
},
|
},
|
||||||
.array_type,
|
.array_type,
|
||||||
.array_type_sentinel,
|
.array_type_sentinel,
|
||||||
@ -941,10 +956,10 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
else
|
else
|
||||||
tree.arrayTypeSentinel(node);
|
tree.arrayTypeSentinel(node);
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, array_type.ast.elem_count });
|
try callWriteNodeTokens(allocator, .{ builder, array_type.ast.elem_count });
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, array_type.ast.sentinel });
|
try callWriteNodeTokens(allocator, .{ builder, array_type.ast.sentinel });
|
||||||
|
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, array_type.ast.elem_type });
|
try callWriteNodeTokens(allocator, .{ builder, array_type.ast.elem_type });
|
||||||
},
|
},
|
||||||
.address_of,
|
.address_of,
|
||||||
.bit_not,
|
.bit_not,
|
||||||
@ -954,25 +969,27 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
|
|||||||
.negation_wrap,
|
.negation_wrap,
|
||||||
=> {
|
=> {
|
||||||
try writeToken(builder, main_token, .operator);
|
try writeToken(builder, main_token, .operator);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
},
|
},
|
||||||
.@"try",
|
.@"try",
|
||||||
.@"resume",
|
.@"resume",
|
||||||
.@"await",
|
.@"await",
|
||||||
=> {
|
=> {
|
||||||
try writeToken(builder, main_token, .keyword);
|
try writeToken(builder, main_token, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, node_data[node].lhs });
|
try callWriteNodeTokens(allocator, .{ builder, node_data[node].lhs });
|
||||||
},
|
},
|
||||||
.anyframe_literal => try writeToken(builder, main_token, .keyword),
|
.anyframe_literal => try writeToken(builder, main_token, .keyword),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn writeContainerField(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *DocumentStore, node: Ast.Node.Index, field_token_type: ?TokenType, child_frame: anytype) !void {
|
fn writeContainerField(builder: *Builder, node: Ast.Node.Index, field_token_type: ?TokenType) !void {
|
||||||
const tree = builder.handle.tree;
|
const tree = builder.handle.tree;
|
||||||
const container_field = ast.containerField(tree, node).?;
|
const container_field = ast.containerField(tree, node).?;
|
||||||
const base = tree.nodes.items(.main_token)[node];
|
const base = tree.nodes.items(.main_token)[node];
|
||||||
const tokens = tree.tokens.items(.tag);
|
const tokens = tree.tokens.items(.tag);
|
||||||
|
|
||||||
|
var allocator = builder.arena.allocator();
|
||||||
|
|
||||||
if (analysis.getDocCommentTokenIndex(tokens, base)) |docs|
|
if (analysis.getDocCommentTokenIndex(tokens, base)) |docs|
|
||||||
try writeDocComments(builder, tree, docs);
|
try writeDocComments(builder, tree, docs);
|
||||||
|
|
||||||
@ -980,10 +997,10 @@ fn writeContainerField(builder: *Builder, arena: *std.heap.ArenaAllocator, store
|
|||||||
if (field_token_type) |tok_type| try writeToken(builder, container_field.ast.name_token, tok_type);
|
if (field_token_type) |tok_type| try writeToken(builder, container_field.ast.name_token, tok_type);
|
||||||
|
|
||||||
if (container_field.ast.type_expr != 0) {
|
if (container_field.ast.type_expr != 0) {
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, container_field.ast.type_expr });
|
try callWriteNodeTokens(allocator, .{ builder, container_field.ast.type_expr });
|
||||||
if (container_field.ast.align_expr != 0) {
|
if (container_field.ast.align_expr != 0) {
|
||||||
try writeToken(builder, tree.firstToken(container_field.ast.align_expr) - 2, .keyword);
|
try writeToken(builder, tree.firstToken(container_field.ast.align_expr) - 2, .keyword);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, container_field.ast.align_expr });
|
try callWriteNodeTokens(allocator, .{ builder, container_field.ast.align_expr });
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -996,19 +1013,18 @@ fn writeContainerField(builder: *Builder, arena: *std.heap.ArenaAllocator, store
|
|||||||
break :block;
|
break :block;
|
||||||
|
|
||||||
try writeToken(builder, eq_tok, .operator);
|
try writeToken(builder, eq_tok, .operator);
|
||||||
try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, container_field.ast.value_expr });
|
try callWriteNodeTokens(allocator, .{ builder, container_field.ast.value_expr });
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// TODO Range version, edit version.
|
// TODO Range version, edit version.
|
||||||
pub fn writeAllSemanticTokens(arena: *std.heap.ArenaAllocator, store: *DocumentStore, handle: *DocumentStore.Handle, encoding: offsets.Encoding) ![]u32 {
|
pub fn writeAllSemanticTokens(arena: *std.heap.ArenaAllocator, store: *DocumentStore, handle: *DocumentStore.Handle, encoding: offsets.Encoding) ![]u32 {
|
||||||
var builder = Builder.init(arena.child_allocator, handle, encoding);
|
var builder = Builder.init(arena, store, handle, encoding);
|
||||||
errdefer builder.arr.deinit(arena.child_allocator);
|
|
||||||
|
|
||||||
// reverse the ast from the root declarations
|
// reverse the ast from the root declarations
|
||||||
var buf: [2]Ast.Node.Index = undefined;
|
var buf: [2]Ast.Node.Index = undefined;
|
||||||
for (ast.declMembers(handle.tree, 0, &buf)) |child| {
|
for (ast.declMembers(handle.tree, 0, &buf)) |child| {
|
||||||
writeNodeTokens(&builder, arena, store, child) catch |err| switch (err) {
|
writeNodeTokens(&builder, child) catch |err| switch (err) {
|
||||||
error.MovedBackwards => break,
|
error.MovedBackwards => break,
|
||||||
else => |e| return e,
|
else => |e| return e,
|
||||||
};
|
};
|
||||||
|
@ -1,4 +1,5 @@
|
|||||||
const std = @import("std");
|
const std = @import("std");
|
||||||
|
const zig_builtin = @import("builtin");
|
||||||
const builtin = @import("builtin");
|
const builtin = @import("builtin");
|
||||||
const Config = @import("Config.zig");
|
const Config = @import("Config.zig");
|
||||||
const ast = @import("ast.zig");
|
const ast = @import("ast.zig");
|
||||||
@ -41,6 +42,20 @@ pub fn convertCInclude(allocator: std.mem.Allocator, tree: Ast, node: Ast.Node.I
|
|||||||
return output.toOwnedSlice(allocator);
|
return output.toOwnedSlice(allocator);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// HACK self-hosted has not implemented async yet
|
||||||
|
fn callConvertCIncludeInternal(allocator: std.mem.Allocator, args: anytype) error{ OutOfMemory, Unsupported }!void {
|
||||||
|
if (zig_builtin.zig_backend == .other or zig_builtin.zig_backend == .stage1) {
|
||||||
|
const FrameSize = @sizeOf(@Frame(convertCIncludeInternal));
|
||||||
|
var child_frame = try allocator.alignedAlloc(u8, std.Target.stack_align, FrameSize);
|
||||||
|
defer allocator.free(child_frame);
|
||||||
|
|
||||||
|
return await @asyncCall(child_frame, {}, convertCIncludeInternal, args);
|
||||||
|
} else {
|
||||||
|
// TODO find a non recursive solution
|
||||||
|
return @call(.{}, convertCIncludeInternal, args);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn convertCIncludeInternal(
|
fn convertCIncludeInternal(
|
||||||
allocator: std.mem.Allocator,
|
allocator: std.mem.Allocator,
|
||||||
stack_allocator: std.mem.Allocator,
|
stack_allocator: std.mem.Allocator,
|
||||||
@ -55,12 +70,8 @@ fn convertCIncludeInternal(
|
|||||||
|
|
||||||
var buffer: [2]Ast.Node.Index = undefined;
|
var buffer: [2]Ast.Node.Index = undefined;
|
||||||
if (ast.isBlock(tree, node)) {
|
if (ast.isBlock(tree, node)) {
|
||||||
const FrameSize = @sizeOf(@Frame(convertCIncludeInternal));
|
|
||||||
var child_frame = try stack_allocator.alignedAlloc(u8, std.Target.stack_align, FrameSize);
|
|
||||||
defer stack_allocator.free(child_frame);
|
|
||||||
|
|
||||||
for (ast.blockStatements(tree, node, &buffer).?) |statement| {
|
for (ast.blockStatements(tree, node, &buffer).?) |statement| {
|
||||||
try await @asyncCall(child_frame, {}, convertCIncludeInternal, .{ allocator, stack_allocator, tree, statement, output });
|
try callConvertCIncludeInternal(stack_allocator, .{ allocator, stack_allocator, tree, statement, output });
|
||||||
}
|
}
|
||||||
} else if (ast.builtinCallParams(tree, node, &buffer)) |params| {
|
} else if (ast.builtinCallParams(tree, node, &buffer)) |params| {
|
||||||
if (params.len < 1) return;
|
if (params.len < 1) return;
|
||||||
|
@ -138,7 +138,7 @@ pub const Diagnostic = struct {
|
|||||||
code: ?string,
|
code: ?string,
|
||||||
source: ?string,
|
source: ?string,
|
||||||
message: string,
|
message: string,
|
||||||
relatedInformation: ?[]const DiagnosticRelatedInformation = null,
|
relatedInformation: ?[]DiagnosticRelatedInformation = null,
|
||||||
};
|
};
|
||||||
|
|
||||||
pub const TextDocument = struct {
|
pub const TextDocument = struct {
|
||||||
|
@ -24,6 +24,8 @@ pub fn fromPath(allocator: std.mem.Allocator, path: []const u8) ![]const u8 {
|
|||||||
const prefix = if (builtin.os.tag == .windows) "file:///" else "file://";
|
const prefix = if (builtin.os.tag == .windows) "file:///" else "file://";
|
||||||
|
|
||||||
var buf = std.ArrayListUnmanaged(u8){};
|
var buf = std.ArrayListUnmanaged(u8){};
|
||||||
|
errdefer buf.deinit(allocator);
|
||||||
|
|
||||||
try buf.appendSlice(allocator, prefix);
|
try buf.appendSlice(allocator, prefix);
|
||||||
|
|
||||||
for (path) |char| {
|
for (path) |char| {
|
||||||
|
@ -249,10 +249,10 @@ fn freeDocument(doc: types.TextDocument) void {
|
|||||||
allocator.free(doc.text);
|
allocator.free(doc.text);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn testContext(line: []const u8, tag: std.meta.Tag(analysis.PositionContext), maybe_range: ?[]const u8) !void {
|
||||||
fn testContext(comptime line: []const u8, comptime tag: std.meta.Tag(analysis.PositionContext), comptime maybe_range: ?[]const u8) !void {
|
const cursor_idx = std.mem.indexOf(u8, line, "<cursor>").?;
|
||||||
const cursor_idx = comptime std.mem.indexOf(u8, line, "<cursor>").?;
|
const final_line = try std.mem.concat(allocator, u8, &.{ line[0..cursor_idx], line[cursor_idx + "<cursor>".len ..] });
|
||||||
const final_line = line[0..cursor_idx] ++ line[cursor_idx + "<cursor>".len ..];
|
defer allocator.free(final_line);
|
||||||
|
|
||||||
const doc = try makeDocument("", line);
|
const doc = try makeDocument("", line);
|
||||||
defer freeDocument(doc);
|
defer freeDocument(doc);
|
||||||
@ -278,7 +278,7 @@ fn testContext(comptime line: []const u8, comptime tag: std.meta.Tag(analysis.Po
|
|||||||
return error.DifferentRange;
|
return error.DifferentRange;
|
||||||
};
|
};
|
||||||
|
|
||||||
const expected_range_start = comptime std.mem.indexOf(u8, final_line, expected_range).?;
|
const expected_range_start = std.mem.indexOf(u8, final_line, expected_range).?;
|
||||||
const expected_range_end = expected_range_start + expected_range.len;
|
const expected_range_end = expected_range_start + expected_range.len;
|
||||||
|
|
||||||
if (expected_range_start != actual_loc.start or expected_range_end != actual_loc.end) {
|
if (expected_range_start != actual_loc.start or expected_range_end != actual_loc.end) {
|
||||||
|
Loading…
Reference in New Issue
Block a user