move config option logic from Server to configuration.Manager

- cache WASI preopens
- allow overriding the preopen directory for `zig_lib_path` and `global_cache_path` on WASI
- refresh diagnostics if `zig_lib_path` changes
- fix some cases where config options would be incorrectly resolved when multiple config sources are combined.

Author: Techatrix

src/Server.zig

@@ -309,7 +309,8 @@ fn functionTypeCompletion(
 
     const info = func_ty.data.function;
 
-    const use_snippets = builder.server.config.enable_snippets and builder.server.client_capabilities.supports_snippets;
+    const config = &builder.server.config_manager.config;
+    const use_snippets = config.enable_snippets and builder.server.client_capabilities.supports_snippets;
 
     const has_self_param = if (parent_container_ty) |container_ty| blk: {
         if (container_ty.is_type_val) break :blk false;
@@ -322,7 +323,7 @@ fn functionTypeCompletion(
     const new_text = switch (new_text_format) {
         .only_name => func_name,
         .snippet => blk: {
-            if (use_snippets and builder.server.config.enable_argument_placeholders) {
+            if (use_snippets and config.enable_argument_placeholders) {
                 break :blk try builder.analyser.stringifyFunction(.{
                     .info = info,
                     .include_fn_keyword = false,
@@ -376,7 +377,7 @@ fn functionTypeCompletion(
             .include_fn_keyword = false,
             .include_name = false,
             .skip_first_param = has_self_param,
-            .parameters = if (builder.server.config.completion_label_details)
+            .parameters = if (config.completion_label_details)
                 .{ .show = .{
                     .include_modifiers = true,
                     .include_names = true,
@@ -444,7 +445,8 @@ fn completeLabel(builder: *Builder) error{OutOfMemory}!void {
 fn populateSnippedCompletions(builder: *Builder, snippets: []const snipped_data.Snipped) error{OutOfMemory}!void {
     try builder.completions.ensureUnusedCapacity(builder.arena, snippets.len);
 
-    const use_snippets = builder.server.config.enable_snippets and builder.server.client_capabilities.supports_snippets;
+    const config = &builder.server.config_manager.config;
+    const use_snippets = config.enable_snippets and builder.server.client_capabilities.supports_snippets;
     for (snippets) |snipped| {
         if (!use_snippets and snipped.kind == .Snippet) continue;
 
@@ -464,7 +466,8 @@ const PrepareFunctionCompletionResult = struct { types.Range, types.Range, Funct
 fn prepareFunctionCompletion(builder: *Builder) PrepareFunctionCompletionResult {
     if (builder.cached_prepare_function_completion_result) |result| return result;
 
-    const use_snippets = builder.server.config.enable_snippets and builder.server.client_capabilities.supports_snippets;
+    const config = &builder.server.config_manager.config;
+    const use_snippets = config.enable_snippets and builder.server.client_capabilities.supports_snippets;
     const source = builder.orig_handle.tree.source;
 
     var start_index = builder.source_index;
@@ -506,8 +509,9 @@ fn completeBuiltin(builder: *Builder) error{OutOfMemory}!void {
     const tracy_zone = tracy.trace(@src());
     defer tracy_zone.end();
 
-    const use_snippets = builder.server.config.enable_snippets and builder.server.client_capabilities.supports_snippets;
-    const use_placeholders = use_snippets and builder.server.config.enable_argument_placeholders;
+    const config = &builder.server.config_manager.config;
+    const use_snippets = config.enable_snippets and builder.server.client_capabilities.supports_snippets;
+    const use_placeholders = use_snippets and config.enable_argument_placeholders;
 
     const insert_range, const replace_range, const new_text_format = prepareFunctionCompletion(builder);
 
@@ -1377,7 +1381,8 @@ fn collectContainerFields(
     const document_scope = try scope_handle.handle.getDocumentScope();
     const scope_decls = document_scope.getScopeDeclarationsConst(scope_handle.scope);
 
-    const use_snippets = builder.server.config.enable_snippets and builder.server.client_capabilities.supports_snippets;
+    const config = &builder.server.config_manager.config;
+    const use_snippets = config.enable_snippets and builder.server.client_capabilities.supports_snippets;
     for (scope_decls) |decl_index| {
         const decl = document_scope.declarations.get(@intFromEnum(decl_index));
         if (decl != .ast_node) continue;

src/configuration.zig

@@ -26,6 +26,8 @@ pub fn generateDiagnostics(
     const tracy_zone = tracy.trace(@src());
     defer tracy_zone.end();
 
+    const config = &server.config_manager.config;
+
     if (handle.tree.errors.len == 0) {
         const tracy_zone2 = tracy.traceNamed(@src(), "ast-check");
         defer tracy_zone2.end();
@@ -68,11 +70,11 @@ pub fn generateDiagnostics(
             try code_actions.collectAutoDiscardDiagnostics(&analyser, handle, arena, &diagnostics, server.offset_encoding);
         }
 
-        if (server.config.warn_style and handle.tree.mode == .zig) {
+        if (config.warn_style and handle.tree.mode == .zig) {
             try collectWarnStyleDiagnostics(handle.tree, arena, &diagnostics, server.offset_encoding);
         }
 
-        if (server.config.highlight_global_var_declarations and handle.tree.mode == .zig) {
+        if (config.highlight_global_var_declarations and handle.tree.mode == .zig) {
             try collectGlobalVarDiagnostics(handle.tree, arena, &diagnostics, server.offset_encoding);
         }
 
@@ -269,15 +271,16 @@ pub fn getAstCheckDiagnostics(server: *Server, handle: *DocumentStore.Handle) er
     defer tracy_zone.end();
 
     std.debug.assert(handle.tree.errors.len == 0);
+    const config = &server.config_manager.config;
 
     if (std.process.can_spawn and
-        server.config.prefer_ast_check_as_child_process and
+        config.prefer_ast_check_as_child_process and
         handle.tree.mode == .zig and // TODO pass `--zon` if available
-        server.config.zig_exe_path != null)
+        config.zig_exe_path != null)
     {
         return getErrorBundleFromAstCheck(
             server.allocator,
-            server.config.zig_exe_path.?,
+            config.zig_exe_path.?,
             &server.zig_ast_check_lock,
             handle.tree.source,
         ) catch |err| {

src/features/completions.zig

@@ -699,7 +699,7 @@ pub fn referencesHandler(server: *Server, arena: std.mem.Allocator, request: Gen
                 decl,
                 server.offset_encoding,
                 include_decl,
-                server.config.skip_std_references,
+                server.config_manager.config.skip_std_references,
                 handle,
             ),
         };

src/features/diagnostics.zig

@@ -404,7 +404,7 @@ fn loadConfiguration(
         config.global_cache_path = try std.fs.path.join(config_arena.allocator(), &.{ cache_dir_path, "zls" });
     }
 
-    try server.updateConfiguration2(&config, .{ .resolve = false });
+    try server.config_manager.setConfiguration2(server.allocator, .frontend, &config);
 }
 
 const ParseArgsResult = struct {
@@ -546,9 +546,12 @@ pub fn main() !u8 {
         log.info("Log File:         none", .{});
     }
 
-    const server = try zls.Server.create(allocator);
+    const server: *zls.Server = try .create(.{
+        .allocator = allocator,
+        .transport = transport,
+        .config = null,
+    });
     defer server.destroy();
-    server.setTransport(transport);
 
     try loadConfiguration(allocator, server, result.config_path);
 

src/features/references.zig

@@ -3,33 +3,27 @@ const zls = @import("zls");
 const builtin = @import("builtin");
 const test_options = @import("test_options");
 
-const Config = zls.Config;
-const Server = zls.Server;
 const types = zls.lsp.types;
 
 const allocator = std.testing.allocator;
 
-const default_config: Config = .{
+const default_config: zls.configuration.UnresolvedConfig = .{
     .semantic_tokens = .full,
     .prefer_ast_check_as_child_process = false,
     .inlay_hints_exclude_single_argument = false,
     .inlay_hints_show_builtin = true,
 };
 
 pub const Context = struct {
-    server: *Server,
+    server: *zls.Server,
     arena: std.heap.ArenaAllocator,
     file_id: u32 = 0,
 
-    var config_arena: std.heap.ArenaAllocator.State = .{};
-    var cached_config: ?Config = null;
-    var cached_resolved_config: ?@FieldType(Server, "resolved_config") = null;
+    var cached_config_arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
+    var cached_config_manager: ?zls.configuration.Manager = null;
 
     pub fn init() !Context {
-        const server = try Server.create(allocator);
-        errdefer server.destroy();
-
-        if (cached_config == null and cached_resolved_config == null) {
+        const config_manager = cached_config_manager orelse config_manager: {
             var config = default_config;
             defer if (builtin.target.os.tag != .wasi) {
                 if (config.zig_exe_path) |zig_exe_path| allocator.free(zig_exe_path);
@@ -44,19 +38,25 @@ pub const Context = struct {
                 config.global_cache_path = try std.fs.path.resolve(allocator, &.{ cwd, test_options.global_cache_path });
             }
 
-            try server.updateConfiguration2(config, .{ .leaky_config_arena = true });
-        } else {
-            // the configuration has previously been resolved and cached.
-            server.config_arena = config_arena;
-            server.config = cached_config.?;
-            server.resolved_config = cached_resolved_config.?;
+            var config_manager: zls.configuration.Manager = .init;
+            try config_manager.setConfiguration(cached_config_arena.allocator(), .frontend, &config);
+            _ = try config_manager.resolveConfiguration(cached_config_arena.allocator());
+            cached_config_manager = config_manager;
+            break :config_manager config_manager;
+        };
 
-            try server.updateConfiguration2(server.config, .{ .leaky_config_arena = true, .resolve = false });
-        }
+        const server: *zls.Server = try .create(.{
+            .allocator = allocator,
+            .transport = null,
+            .config = null,
+            .config_manager = config_manager,
+        });
+        errdefer server.destroy();
 
-        std.debug.assert(server.resolved_config.zig_lib_dir != null);
+        std.debug.assert(server.config_manager.zig_lib_dir != null);
         std.debug.assert(server.document_store.config.zig_lib_dir != null);
-        std.debug.assert(server.resolved_config.global_cache_dir != null);
+
+        std.debug.assert(server.config_manager.global_cache_dir != null);
         std.debug.assert(server.document_store.config.global_cache_dir != null);
 
         var context: Context = .{
@@ -71,13 +71,7 @@ pub const Context = struct {
     }
 
     pub fn deinit(self: *Context) void {
-        config_arena = self.server.config_arena;
-        cached_config = self.server.config;
-        cached_resolved_config = self.server.resolved_config;
-
-        self.server.config_arena = .{};
-        self.server.config = .{};
-        self.server.resolved_config = .unresolved;
+        self.server.config_manager = .init;
 
         _ = self.server.sendRequestSync(self.arena.allocator(), "shutdown", {}) catch unreachable;
         self.server.sendNotificationSync(self.arena.allocator(), "exit", {}) catch unreachable;

src/main.zig

@@ -6,29 +6,13 @@ const test_options = @import("test_options");
 const allocator = std.testing.allocator;
 
 test "LSP lifecycle" {
-    var server = try zls.Server.create(allocator);
+    var server: *zls.Server = try .create(.{
+        .allocator = allocator,
+        .transport = null,
+        .config = null,
+    });
     defer server.destroy();
 
-    var zig_exe_path: ?[]const u8 = null;
-    var global_cache_path: ?[]const u8 = null;
-
-    defer if (builtin.target.os.tag != .wasi) {
-        if (zig_exe_path) |path| allocator.free(path);
-        if (global_cache_path) |path| allocator.free(path);
-    };
-    if (builtin.target.os.tag != .wasi) {
-        const cwd = try std.process.getCwdAlloc(allocator);
-        defer allocator.free(cwd);
-        zig_exe_path = try std.fs.path.resolve(allocator, &.{ cwd, test_options.zig_exe_path });
-        global_cache_path = try std.fs.path.resolve(allocator, &.{ cwd, test_options.global_cache_path });
-    }
-
-    try server.updateConfiguration2(.{
-        .zig_exe_path = zig_exe_path,
-        .zig_lib_path = null,
-        .global_cache_path = global_cache_path,
-    }, .{});
-
     var arena_allocator: std.heap.ArenaAllocator = .init(allocator);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();

tests/context.zig

@@ -935,7 +935,7 @@ fn testDiagnostic(
 ) !void {
     var ctx: Context = try .init();
     defer ctx.deinit();
-    ctx.server.config.prefer_ast_check_as_child_process = !options.want_zir;
+    ctx.server.config_manager.config.prefer_ast_check_as_child_process = !options.want_zir;
 
     var phr = try helper.collectClearPlaceholders(allocator, before);
     defer phr.deinit(allocator);

tests/lifecycle.zig

@@ -4275,9 +4275,9 @@ fn testCompletionWithOptions(
     ctx.server.client_capabilities.supports_completion_deprecated_old = true;
     ctx.server.client_capabilities.supports_completion_deprecated_tag = true;
 
-    ctx.server.config.enable_argument_placeholders = options.enable_argument_placeholders;
-    ctx.server.config.enable_snippets = options.enable_snippets;
-    ctx.server.config.completion_label_details = options.completion_label_details;
+    ctx.server.config_manager.config.enable_argument_placeholders = options.enable_argument_placeholders;
+    ctx.server.config_manager.config.enable_snippets = options.enable_snippets;
+    ctx.server.config_manager.config.completion_label_details = options.completion_label_details;
 
     const test_uri = try ctx.addDocument(.{ .source = text });
 
@@ -4512,8 +4512,8 @@ fn testCompletionTextEdit(
 
     ctx.server.client_capabilities.supports_snippets = true;
 
-    ctx.server.config.enable_argument_placeholders = options.enable_argument_placeholders;
-    ctx.server.config.enable_snippets = options.enable_snippets;
+    ctx.server.config_manager.config.enable_argument_placeholders = options.enable_argument_placeholders;
+    ctx.server.config_manager.config.enable_snippets = options.enable_snippets;
 
     const test_uri = try ctx.addDocument(.{ .source = text });
     const handle = ctx.server.document_store.getHandle(test_uri).?;