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

do not store Handle pointer in Analyser

Browse Source
This commit is contained in:
Techatrix 2023-03-13 01:08:22 +01:00 committed by Lee Cannon
parent 9d7012596a
commit f5897569c4
1 changed files with 18 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/analysis.zig
View File

@ -17,7 +17,7 @@ arena: std.mem.Allocator,
store: *DocumentStore, store: *DocumentStore,
bound_type_params: std.AutoHashMapUnmanaged(Ast.full.FnProto.Param, TypeWithHandle) = .{}, bound_type_params: std.AutoHashMapUnmanaged(Ast.full.FnProto.Param, TypeWithHandle) = .{},
using_trail: std.AutoHashMapUnmanaged(Ast.Node.Index, void) = .{}, using_trail: std.AutoHashMapUnmanaged(Ast.Node.Index, void) = .{},
resolved_nodes: std.HashMapUnmanaged(NodeWithHandle, ?TypeWithHandle, NodeWithHandle.Context, std.hash_map.default_max_load_percentage) = .{}, resolved_nodes: std.HashMapUnmanaged(NodeWithUri, ?TypeWithHandle, NodeWithUri.Context, std.hash_map.default_max_load_percentage) = .{},
pub fn init(gpa: std.mem.Allocator, arena: std.mem.Allocator, store: *DocumentStore) Analyser { pub fn init(gpa: std.mem.Allocator, arena: std.mem.Allocator, store: *DocumentStore) Analyser {
return .{ return .{
@ -662,14 +662,18 @@ pub fn isTypeIdent(text: []const u8) bool {
/// Resolves the type of a node /// Resolves the type of a node
fn resolveTypeOfNodeInternal(analyser: *Analyser, node_handle: NodeWithHandle) error{OutOfMemory}!?TypeWithHandle { fn resolveTypeOfNodeInternal(analyser: *Analyser, node_handle: NodeWithHandle) error{OutOfMemory}!?TypeWithHandle {
const gop = try analyser.resolved_nodes.getOrPut(analyser.gpa, node_handle); const node_with_uri = NodeWithUri{
.node = node_handle.node,
.uri = node_handle.handle.uri,
};
const gop = try analyser.resolved_nodes.getOrPut(analyser.gpa, node_with_uri);
if (gop.found_existing) return gop.value_ptr.*; if (gop.found_existing) return gop.value_ptr.*;
// we insert null before resolving the type so that a recursive definition doesn't result in an infinite loop // we insert null before resolving the type so that a recursive definition doesn't result in an infinite loop
gop.value_ptr.* = null; gop.value_ptr.* = null;
const type_handle = try analyser.resolveTypeOfNodeUncached(node_handle); const type_handle = try analyser.resolveTypeOfNodeUncached(node_handle);
analyser.resolved_nodes.getPtr(node_handle).?.* = type_handle; analyser.resolved_nodes.getPtr(node_with_uri).?.* = type_handle;
return type_handle; return type_handle;
@ -1336,27 +1340,32 @@ pub fn collectCImportNodes(allocator: std.mem.Allocator, tree: Ast) error{OutOfM
return import_nodes.toOwnedSlice(allocator); return import_nodes.toOwnedSlice(allocator);
} }
pub const NodeWithHandle = struct { pub const NodeWithUri = struct {
node: Ast.Node.Index, node: Ast.Node.Index,
handle: *const DocumentStore.Handle, uri: []const u8,
const Context = struct { const Context = struct {
pub fn hash(self: @This(), item: NodeWithHandle) u64 { pub fn hash(self: @This(), item: NodeWithUri) u64 {
_ = self; _ = self;
var hasher = std.hash.Wyhash.init(0); var hasher = std.hash.Wyhash.init(0);
std.hash.autoHash(&hasher, item.node); std.hash.autoHash(&hasher, item.node);
hasher.update(item.handle.uri); hasher.update(item.uri);
return hasher.final(); return hasher.final();
} }
pub fn eql(self: @This(), a: NodeWithHandle, b: NodeWithHandle) bool { pub fn eql(self: @This(), a: NodeWithUri, b: NodeWithUri) bool {
_ = self; _ = self;
if (a.node != b.node) return false; if (a.node != b.node) return false;
return std.mem.eql(u8, a.handle.uri, b.handle.uri); return std.mem.eql(u8, a.uri, b.uri);
} }
}; };
}; };
pub const NodeWithHandle = struct {
node: Ast.Node.Index,
handle: *const DocumentStore.Handle,
};
pub const FieldAccessReturn = struct { pub const FieldAccessReturn = struct {
original: TypeWithHandle, original: TypeWithHandle,
unwrapped: ?TypeWithHandle = null, unwrapped: ?TypeWithHandle = null,