fix: wrong build file associated

src/ComptimeInterpreter.zig

@@ -892,7 +892,7 @@ pub fn interpret(
                     } };
                 }
 
-                const import_uri = (try interpreter.document_store.uriFromImportStr(interpreter.allocator, interpreter.getHandle().*, import_str[1 .. import_str.len - 1])) orelse return error.ImportFailure;
+                const import_uri = (try interpreter.document_store.uriFromImportStr(interpreter.allocator, interpreter.getHandle(), import_str[1 .. import_str.len - 1])) orelse return error.ImportFailure;
                 defer interpreter.allocator.free(import_uri);
 
                 const import_handle = interpreter.document_store.getOrLoadHandle(import_uri) orelse return error.ImportFailure;

src/Server.zig

@@ -142,14 +142,20 @@ pub const Status = enum {
 const Job = union(enum) {
     incoming_message: std.json.Parsed(Message),
     generate_diagnostics: DocumentStore.Uri,
-    load_build_configuration: DocumentStore.Uri,
+    load_build_configuration: struct {
+        build_file_uri: DocumentStore.Uri,
+        maybe_handle_uri: ?DocumentStore.Uri = null,
+    },
     run_build_on_save,
 
     fn deinit(self: Job, allocator: std.mem.Allocator) void {
         switch (self) {
             .incoming_message => |parsed_message| parsed_message.deinit(),
             .generate_diagnostics => |uri| allocator.free(uri),
-            .load_build_configuration => |uri| allocator.free(uri),
+            .load_build_configuration => |params| {
+                allocator.free(params.build_file_uri);
+                if (params.maybe_handle_uri) |handle_uri| allocator.free(handle_uri);
+            },
             .run_build_on_save => {},
         }
     }
@@ -681,7 +687,7 @@ fn invalidateAllBuildFiles(server: *Server) error{OutOfMemory}!void {
     try server.job_queue.ensureUnusedCapacity(server.document_store.build_files.count());
     for (server.document_store.build_files.keys()) |build_file_uri| {
         server.job_queue.writeItemAssumeCapacity(.{
-            .load_build_configuration = try server.allocator.dupe(u8, build_file_uri),
+            .load_build_configuration = .{ .build_file_uri = try server.allocator.dupe(u8, build_file_uri) },
         });
     }
 }
@@ -1195,7 +1201,7 @@ fn saveDocumentHandler(server: *Server, arena: std.mem.Allocator, notification:
 
     if (std.process.can_spawn and DocumentStore.isBuildFile(uri)) {
         try server.pushJob(.{
-            .load_build_configuration = try server.allocator.dupe(u8, uri),
+            .load_build_configuration = .{ .build_file_uri = try server.allocator.dupe(u8, uri) },
         });
     }
 
@@ -2031,10 +2037,10 @@ fn processJob(server: *Server, job: Job, wait_group: ?*std.Thread.WaitGroup) voi
             const json_message = server.sendToClientNotification("textDocument/publishDiagnostics", diagnostics) catch return;
             server.allocator.free(json_message);
         },
-        .load_build_configuration => |build_file_uri| {
+        .load_build_configuration => |params| {
             std.debug.assert(std.process.can_spawn);
             if (!std.process.can_spawn) return;
-            server.document_store.invalidateBuildFile(build_file_uri) catch return;
+            server.document_store.invalidateBuildFile(params.build_file_uri, params.maybe_handle_uri) catch return;
         },
         .run_build_on_save => {
             std.debug.assert(std.process.can_spawn);

src/analysis.zig

@@ -1507,11 +1507,11 @@ fn resolveTypeOfNodeUncached(analyser: *Analyser, node_handle: NodeWithHandle) e
                 const import_str = tree.tokenSlice(main_tokens[import_param]);
                 const import_uri = (try analyser.store.uriFromImportStr(
                     analyser.arena.allocator(),
-                    handle.*,
+                    handle,
                     import_str[1 .. import_str.len - 1],
                 )) orelse (try analyser.store.uriFromImportStr(
                     analyser.arena.allocator(),
-                    if (analyser.root_handle) |root_handle| root_handle.* else return null,
+                    if (analyser.root_handle) |root_handle| root_handle else return null,
                     import_str[1 .. import_str.len - 1],
                 )) orelse return null;
 
@@ -1520,7 +1520,7 @@ fn resolveTypeOfNodeUncached(analyser: *Analyser, node_handle: NodeWithHandle) e
                 // reference to node '0' which is root
                 return TypeWithHandle.typeVal(.{ .node = 0, .handle = new_handle });
             } else if (std.mem.eql(u8, call_name, "@cImport")) {
-                const cimport_uri = (try analyser.store.resolveCImport(handle.*, node)) orelse return null;
+                const cimport_uri = (try analyser.store.resolveCImport(handle, node)) orelse return null;
 
                 const new_handle = analyser.store.getOrLoadHandle(cimport_uri) orelse return null;
 
@@ -2533,7 +2533,7 @@ pub fn getFieldAccessType(
                         .start = import_str_tok.loc.start + 1,
                         .end = import_str_tok.loc.end - 1,
                     });
-                    const uri = try analyser.store.uriFromImportStr(analyser.arena.allocator(), curr_handle.*, import_str) orelse return null;
+                    const uri = try analyser.store.uriFromImportStr(analyser.arena.allocator(), curr_handle, import_str) orelse return null;
                     const node_handle = analyser.store.getOrLoadHandle(uri) orelse return null;
                     current_type = TypeWithHandle.typeVal(NodeWithHandle{ .handle = node_handle, .node = 0 });
                     _ = tokenizer.next(); // eat the .r_paren

src/features/completions.zig

@@ -738,7 +738,7 @@ fn completeError(server: *Server, arena: std.mem.Allocator, handle: *DocumentSto
     const tracy_zone = tracy.trace(@src());
     defer tracy_zone.end();
 
-    return try server.document_store.errorCompletionItems(arena, handle.*);
+    return try server.document_store.errorCompletionItems(arena, handle);
 }
 
 fn kindToSortScore(kind: types.CompletionItemKind) ?[]const u8 {
@@ -808,7 +808,7 @@ fn completeDot(document_store: *DocumentStore, analyser: *Analyser, arena: std.m
     if (token_tags[dot_token_index - 1] == .number_literal or token_tags[dot_token_index - 1] != .equal) return &.{};
 
     // `var enum_val = .` or the get*Context logic failed because of syntax errors (parser didn't create the necessary node(s))
-    const enum_completions = try document_store.enumCompletionItems(arena, handle.*);
+    const enum_completions = try document_store.enumCompletionItems(arena, handle);
     return enum_completions;
 }
 
@@ -820,7 +820,7 @@ fn completeDot(document_store: *DocumentStore, analyser: *Analyser, arena: std.m
 fn completeFileSystemStringLiteral(
     arena: std.mem.Allocator,
     store: *DocumentStore,
-    handle: DocumentStore.Handle,
+    handle: *DocumentStore.Handle,
     pos_context: Analyser.PositionContext,
 ) ![]types.CompletionItem {
     var completions: DocumentScope.CompletionSet = .{};
@@ -893,10 +893,11 @@ fn completeFileSystemStringLiteral(
     }
 
     if (completing.len == 0 and pos_context == .import_string_literal) {
-        if (handle.associated_build_file) |uri| blk: {
+        if (handle.getAssociatedBuildFileUri(store, true)) |uri| blk: {
+            defer handle.unlockShared();
             const build_file = store.getBuildFile(uri).?;
-            const build_config = build_file.tryLockConfig() orelse break :blk;
-            defer build_file.unlockConfig();
+            const build_config = build_file.getConfig() orelse break :blk;
+            defer build_file.unlockShared();
 
             try completions.ensureUnusedCapacity(arena, build_config.packages.len);
             for (build_config.packages) |pkg| {
@@ -908,8 +909,8 @@ fn completeFileSystemStringLiteral(
             }
         } else if (DocumentStore.isBuildFile(handle.uri)) blk: {
             const build_file = store.getBuildFile(handle.uri) orelse break :blk;
-            const build_config = build_file.tryLockConfig() orelse break :blk;
-            defer build_file.unlockConfig();
+            const build_config = build_file.getConfig() orelse break :blk;
+            defer build_file.unlockShared();
 
             try completions.ensureUnusedCapacity(arena, build_config.deps_build_roots.len);
             for (build_config.deps_build_roots) |dbr| {
@@ -970,7 +971,7 @@ pub fn completionAtIndex(server: *Server, analyser: *Analyser, arena: std.mem.Al
         .string_literal,
         => blk: {
             if (pos_context == .string_literal and !DocumentStore.isBuildFile(handle.uri)) break :blk null;
-            break :blk completeFileSystemStringLiteral(arena, &server.document_store, handle.*, pos_context) catch |err| {
+            break :blk completeFileSystemStringLiteral(arena, &server.document_store, handle, pos_context) catch |err| {
                 log.err("failed to get file system completions: {}", .{err});
                 return null;
             };

src/features/goto.zig

@@ -204,13 +204,13 @@ fn gotoDefinitionString(
     const uri = switch (pos_context) {
         .import_string_literal,
         .embedfile_string_literal,
-        => try document_store.uriFromImportStr(arena, handle.*, import_str),
+        => try document_store.uriFromImportStr(arena, handle, import_str),
         .cinclude_string_literal => try URI.fromPath(
             arena,
             blk: {
                 if (std.fs.path.isAbsolute(import_str)) break :blk import_str;
                 var include_dirs: std.ArrayListUnmanaged([]const u8) = .{};
-                _ = document_store.collectIncludeDirs(arena, handle.*, &include_dirs) catch |err| {
+                _ = document_store.collectIncludeDirs(arena, handle, &include_dirs) catch |err| {
                     log.err("failed to resolve include paths: {}", .{err});
                     return null;
                 };

src/features/references.zig

@@ -159,7 +159,7 @@ fn gatherReferences(
 
         var handle_dependencies = std.ArrayListUnmanaged([]const u8){};
         defer handle_dependencies.deinit(allocator);
-        try analyser.store.collectDependencies(allocator, handle.*, &handle_dependencies);
+        try analyser.store.collectDependencies(allocator, handle, &handle_dependencies);
 
         try dependencies.ensureUnusedCapacity(allocator, handle_dependencies.items.len);
         for (handle_dependencies.items) |uri| {