use std.Thread.Pool even when building with -Dsingle-threaded

Author: Techatrix

src/DocumentStore.zig

@@ -22,7 +22,7 @@ allocator: std.mem.Allocator,
 /// the DocumentStore assumes that `config` is not modified while calling one of its functions.
 config: Config,
 lock: std.Thread.RwLock = .{},
-thread_pool: if (builtin.single_threaded) void else *std.Thread.Pool,
+thread_pool: *std.Thread.Pool,
 handles: std.StringArrayHashMapUnmanaged(*Handle) = .empty,
 build_files: if (supports_build_system) std.StringArrayHashMapUnmanaged(*BuildFile) else void = if (supports_build_system) .empty else {},
 cimports: if (supports_build_system) std.AutoArrayHashMapUnmanaged(Hash, translate_c.Result) else void = if (supports_build_system) .empty else {},
@@ -80,7 +80,7 @@ pub const BuildFile = struct {
     build_associated_config: ?std.json.Parsed(BuildAssociatedConfig) = null,
     impl: struct {
         mutex: std.Thread.Mutex = .{},
-        build_runner_state: if (builtin.single_threaded) void else BuildRunnerState = if (builtin.single_threaded) {} else .idle,
+        build_runner_state: BuildRunnerState = .idle,
         version: u32 = 0,
         /// contains information extracted from running build.zig with a custom build runner
         /// e.g. include paths & packages
@@ -835,11 +835,6 @@ pub fn invalidateBuildFile(self: *DocumentStore, build_file_uri: Uri) void {
 
     const build_file = self.getBuildFile(build_file_uri) orelse return;
 
-    if (builtin.single_threaded) {
-        self.invalidateBuildFileWorker(build_file);
-        return;
-    }
-
     self.thread_pool.spawn(invalidateBuildFileWorker, .{ self, build_file }) catch {
         self.invalidateBuildFileWorker(build_file);
         return;
@@ -1474,17 +1469,11 @@ pub fn loadDirectoryRecursive(store: *DocumentStore, directory_uri: Uri) !usize
         }
     };
 
-    if (builtin.single_threaded) {
-        while (not_currently_loading_uris.pop()) |uri| {
-            S.getOrLoadHandleVoid(store, uri);
-        }
-    } else {
-        var wait_group: std.Thread.WaitGroup = .{};
-        while (not_currently_loading_uris.pop()) |uri| {
-            store.thread_pool.spawnWg(&wait_group, S.getOrLoadHandleVoid, .{ store, uri });
-        }
-        store.thread_pool.waitAndWork(&wait_group);
+    var wait_group: std.Thread.WaitGroup = .{};
+    while (not_currently_loading_uris.pop()) |uri| {
+        store.thread_pool.spawnWg(&wait_group, S.getOrLoadHandleVoid, .{ store, uri });
     }
+    store.thread_pool.waitAndWork(&wait_group);
 
     return file_count;
 }

src/Server.zig

@@ -56,8 +56,7 @@ offset_encoding: offsets.Encoding = .@"utf-16",
 status: Status = .uninitialized,
 
 // private fields
-thread_pool: if (zig_builtin.single_threaded) void else std.Thread.Pool,
-wait_group: if (zig_builtin.single_threaded) void else std.Thread.WaitGroup,
+thread_pool: std.Thread.Pool,
 job_queue: std.fifo.LinearFifo(Job, .Dynamic),
 job_queue_lock: std.Thread.Mutex = .{},
 ip: InternPool = undefined,
@@ -2116,43 +2115,35 @@ fn isBlockingMessage(msg: Message) bool {
 /// make sure to also set the `transport` field
 pub fn create(allocator: std.mem.Allocator) !*Server {
     const server = try allocator.create(Server);
-    errdefer server.destroy();
+    errdefer allocator.destroy(server);
     server.* = .{
         .allocator = allocator,
         .config = .{},
         .document_store = .{
             .allocator = allocator,
             .config = .init,
-            .thread_pool = if (zig_builtin.single_threaded) {} else undefined, // set below
+            .thread_pool = &server.thread_pool,
             .diagnostics_collection = &server.diagnostics_collection,
         },
         .job_queue = .init(allocator),
         .thread_pool = undefined, // set below
-        .wait_group = if (zig_builtin.single_threaded) {} else .{},
         .diagnostics_collection = .{ .allocator = allocator },
     };
 
-    if (zig_builtin.single_threaded) {
-        server.thread_pool = {};
-    } else {
-        try server.thread_pool.init(.{
-            .allocator = allocator,
-            .n_jobs = @min(4, std.Thread.getCpuCount() catch 1), // what is a good value here?
-        });
-        server.document_store.thread_pool = &server.thread_pool;
-    }
+    try server.thread_pool.init(.{
+        .allocator = allocator,
+        .n_jobs = @min(4, std.Thread.getCpuCount() catch 1), // what is a good value here?
+    });
+    errdefer server.thread_pool.deinit();
 
     server.ip = try InternPool.init(allocator);
+    errdefer server.ip.deinit(allocator);
 
     return server;
 }
 
 pub fn destroy(server: *Server) void {
-    if (!zig_builtin.single_threaded) {
-        server.wait_group.wait();
-        server.thread_pool.deinit();
-    }
-
+    server.thread_pool.deinit();
     while (server.job_queue.readItem()) |job| job.deinit(server.allocator);
     server.job_queue.deinit();
     server.document_store.deinit();
@@ -2179,34 +2170,27 @@ pub fn keepRunning(server: Server) bool {
     }
 }
 
-pub fn waitAndWork(server: *Server) void {
-    if (zig_builtin.single_threaded) return;
-    server.thread_pool.waitAndWork(&server.wait_group);
-    server.wait_group.reset();
-}
-
 /// The main loop of ZLS
 pub fn loop(server: *Server) !void {
     std.debug.assert(server.transport != null);
+    var wait_group: std.Thread.WaitGroup = .{};
     while (server.keepRunning()) {
         const json_message = try server.transport.?.readJsonMessage(server.allocator);
         defer server.allocator.free(json_message);
 
         try server.sendJsonMessage(json_message);
 
         while (server.job_queue.readItem()) |job| {
-            if (zig_builtin.single_threaded) {
-                server.processJob(job);
-                continue;
-            }
-
             switch (job.syncMode()) {
                 .exclusive => {
-                    server.waitAndWork();
+                    if (!zig_builtin.single_threaded) {
+                        server.thread_pool.waitAndWork(&wait_group);
+                        wait_group.reset();
+                    }
                     server.processJob(job);
                 },
                 .shared => {
-                    server.thread_pool.spawnWg(&server.wait_group, processJob, .{ server, job });
+                    server.thread_pool.spawnWg(&wait_group, processJob, .{ server, job });
                 },
             }
         }