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

Use the correct tree to display semantic tokens

Browse Source
This commit is contained in:
Luuk de Gram 2021-03-04 22:53:54 +01:00
parent 9224bbd4dc
commit acc45b4efe
No known key found for this signature in database
GPG Key ID: A002B174963DBB7D
2 changed files with 29 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/analysis.zig
View File

@ -983,7 +983,8 @@ pub const TypeWithHandle = struct {
} }
} }
fn isContainerKind(self: TypeWithHandle, container_kind_tok: std.zig.Token.Tag, tree: ast.Tree) bool { fn isContainerKind(self: TypeWithHandle, container_kind_tok: std.zig.Token.Tag) bool {
const tree = self.handle.tree;
const main_tokens = tree.nodes.items(.main_token); const main_tokens = tree.nodes.items(.main_token);
const tags = tree.tokens.items(.tag); const tags = tree.tokens.items(.tag);
switch (self.type.data) { switch (self.type.data) {
@ -992,13 +993,13 @@ pub const TypeWithHandle = struct {
} }
} }
pub fn isStructType(self: TypeWithHandle, tree: ast.Tree) bool { pub fn isStructType(self: TypeWithHandle) bool {
return self.isContainerKind(.keyword_struct, tree) or self.isRoot(); return self.isContainerKind(.keyword_struct) or self.isRoot();
} }
pub fn isNamespace(self: TypeWithHandle, tree: ast.Tree) bool { pub fn isNamespace(self: TypeWithHandle) bool {
if (!self.isStructType(tree)) return false; if (!self.isStructType()) return false;
const tree = self.handle.tree;
const node = self.type.data.other; const node = self.type.data.other;
const tags = tree.nodes.items(.tag); const tags = tree.nodes.items(.tag);
if (isContainer(tags[node])) { if (isContainer(tags[node])) {
@ -1010,20 +1011,21 @@ pub const TypeWithHandle = struct {
return true; return true;
} }
pub fn isEnumType(self: TypeWithHandle, tree: ast.Tree) bool { pub fn isEnumType(self: TypeWithHandle) bool {
return self.isContainerKind(.keyword_enum, tree); return self.isContainerKind(.keyword_enum);
} }
pub fn isUnionType(self: TypeWithHandle, tree: ast.Tree) bool { pub fn isUnionType(self: TypeWithHandle) bool {
return self.isContainerKind(.keyword_union, tree); return self.isContainerKind(.keyword_union);
} }
pub fn isOpaqueType(self: TypeWithHandle, tree: ast.Tree) bool { pub fn isOpaqueType(self: TypeWithHandle) bool {
return self.isContainerKind(.keyword_opaque, tree); return self.isContainerKind(.keyword_opaque);
} }
pub fn isTypeFunc(self: TypeWithHandle, tree: ast.Tree) bool { pub fn isTypeFunc(self: TypeWithHandle) bool {
var buf: [1]ast.Node.Index = undefined; var buf: [1]ast.Node.Index = undefined;
const tree = self.handle.tree;
return switch (self.type.data) { return switch (self.type.data) {
.other => |n| if (fnProto(tree, n, &buf)) |fn_proto| blk: { .other => |n| if (fnProto(tree, n, &buf)) |fn_proto| blk: {
break :blk isTypeFunction(tree, fn_proto); break :blk isTypeFunction(tree, fn_proto);
@ -1032,8 +1034,9 @@ pub const TypeWithHandle = struct {
}; };
} }
pub fn isGenericFunc(self: TypeWithHandle, tree: ast.Tree) bool { pub fn isGenericFunc(self: TypeWithHandle) bool {
var buf: [1]ast.Node.Index = undefined; var buf: [1]ast.Node.Index = undefined;
const tree = self.handle.tree;
return switch (self.type.data) { return switch (self.type.data) {
.other => |n| if (fnProto(tree, n, &buf)) |fn_proto| blk: { .other => |n| if (fnProto(tree, n, &buf)) |fn_proto| blk: {
break :blk isGenericFunction(tree, fn_proto); break :blk isGenericFunction(tree, fn_proto);
@ -1042,7 +1045,8 @@ pub const TypeWithHandle = struct {
}; };
} }
pub fn isFunc(self: TypeWithHandle, tree: ast.Tree) bool { pub fn isFunc(self: TypeWithHandle) bool {
const tree = self.handle.tree;
const tags = tree.nodes.items(.tag); const tags = tree.nodes.items(.tag);
return switch (self.type.data) { return switch (self.type.data) {
.other => |n| switch (tags[n]) { .other => |n| switch (tags[n]) {
@ -1867,16 +1871,6 @@ pub const DeclWithHandle = struct {
}, bound_type_params)) orelse return null, }, bound_type_params)) orelse return null,
bound_type_params, bound_type_params,
), ),
// .array_payload => |pay| try resolveBracketAccessType(
// store,
// arena,
// (try resolveTypeOfNodeInternal(store, arena, .{
// .node = pay.array_expr,
// .handle = self.handle,
// }, bound_type_params)) orelse return null,
// .Single,
// bound_type_params,
// ),
.label_decl => return null, .label_decl => return null,
.switch_payload => |pay| { .switch_payload => |pay| {
if (pay.items.len == 0) return null; if (pay.items.len == 0) return null;
@ -1885,7 +1879,7 @@ pub const DeclWithHandle = struct {
.node = pay.switch_expr, .node = pay.switch_expr,
.handle = self.handle, .handle = self.handle,
}, bound_type_params)) orelse return null; }, bound_type_params)) orelse return null;
if (!switch_expr_type.isUnionType(tree)) if (!switch_expr_type.isUnionType())
return null; return null;
if (node_tags[pay.items[0]] == .enum_literal) { if (node_tags[pay.items[0]] == .enum_literal) {

17
src/semantic_tokens.zig
View File

@ -199,23 +199,23 @@ fn colorIdentifierBasedOnType(builder: *Builder, type_node: analysis.TypeWithHan
const tree = builder.handle.tree; const tree = builder.handle.tree;
if (type_node.type.is_type_val) { if (type_node.type.is_type_val) {
var new_tok_mod = tok_mod; var new_tok_mod = tok_mod;
if (type_node.isNamespace(tree)) if (type_node.isNamespace())
new_tok_mod.set("namespace") new_tok_mod.set("namespace")
else if (type_node.isStructType(tree)) else if (type_node.isStructType())
new_tok_mod.set("struct") new_tok_mod.set("struct")
else if (type_node.isEnumType(tree)) else if (type_node.isEnumType())
new_tok_mod.set("enum") new_tok_mod.set("enum")
else if (type_node.isUnionType(tree)) else if (type_node.isUnionType())
new_tok_mod.set("union") new_tok_mod.set("union")
else if (type_node.isOpaqueType(tree)) else if (type_node.isOpaqueType())
new_tok_mod.set("opaque"); new_tok_mod.set("opaque");
try writeTokenMod(builder, target_tok, .type, new_tok_mod); try writeTokenMod(builder, target_tok, .type, new_tok_mod);
} else if (type_node.isTypeFunc(tree)) { } else if (type_node.isTypeFunc()) {
try writeTokenMod(builder, target_tok, .type, tok_mod); try writeTokenMod(builder, target_tok, .type, tok_mod);
} else if (type_node.isFunc(tree)) { } else if (type_node.isFunc()) {
var new_tok_mod = tok_mod; var new_tok_mod = tok_mod;
if (type_node.isGenericFunc(tree)) { if (type_node.isGenericFunc()) {
new_tok_mod.set("generic"); new_tok_mod.set("generic");
} }
try writeTokenMod(builder, target_tok, .function, new_tok_mod); try writeTokenMod(builder, target_tok, .function, new_tok_mod);
@ -277,6 +277,7 @@ fn writeNodeTokens(
const main_tokens = tree.nodes.items(.main_token); const main_tokens = tree.nodes.items(.main_token);
const node = maybe_node.?; const node = maybe_node.?;
if (node > node_tags.len) return;
const tag = node_tags[node]; const tag = node_tags[node];
const main_token = main_tokens[node]; const main_token = main_tokens[node];