From 90c221259e48a6a4a5d08ad94dbab81418e409b1 Mon Sep 17 00:00:00 2001 From: Techatrix Date: Tue, 14 Apr 2026 01:09:10 +0200 Subject: [PATCH 01/14] update usage of array hash map --- build.zig | 4 +-- src/DiagnosticsCollection.zig | 2 +- src/DocumentScope.zig | 2 +- src/DocumentStore.zig | 4 +-- src/Server.zig | 8 +++--- src/TrigramStore.zig | 4 +-- src/Uri.zig | 2 +- src/analyser/InternPool.zig | 18 ++++++------- src/analysis.zig | 10 +++---- src/build_runner/build_runner.zig | 44 +++++++++++++++---------------- src/features/code_actions.zig | 2 +- src/features/completions.zig | 2 +- src/features/diagnostics.zig | 4 +-- src/features/references.zig | 2 +- tests/ErrorBuilder.zig | 2 +- tests/lsp_features/completion.zig | 22 ++++++++-------- tests/lsp_features/references.zig | 4 +-- 17 files changed, 68 insertions(+), 68 deletions(-) diff --git a/build.zig b/build.zig index 9f0dfd6fc..0aa77cc73 100644 --- a/build.zig +++ b/build.zig @@ -188,7 +188,7 @@ pub fn build(b: *Build) !void { .build_options = build_options, .version_data = version_data_module, }); - b.modules.put("zls", zls_module) catch @panic("OOM"); + b.modules.put(b.allocator, "zls", zls_module) catch @panic("OOM"); const known_folders_module = b.dependency("known_folders", .{ .target = target, @@ -498,7 +498,7 @@ fn release(b: *Build, release_artifacts: []const *Build.Step.Compile, released_z @"tar.gz", }; - var compressed_artifacts: std.StringArrayHashMapUnmanaged(std.Build.LazyPath) = .empty; + var compressed_artifacts: std.array_hash_map.String(std.Build.LazyPath) = .empty; for (release_artifacts) |exe| { const resolved_target = exe.root_module.resolved_target.?.result; diff --git a/src/DiagnosticsCollection.zig b/src/DiagnosticsCollection.zig index 442f7806f..2dbbe165c 100644 --- a/src/DiagnosticsCollection.zig +++ b/src/DiagnosticsCollection.zig @@ -7,7 +7,7 @@ const Uri = @import("Uri.zig"); io: std.Io, allocator: std.mem.Allocator, mutex: std.Io.Mutex = .init, -tag_set: std.AutoArrayHashMapUnmanaged(Tag, struct { +tag_set: std.array_hash_map.Auto(Tag, struct { version: u32 = 0, error_bundle_src_base_path: ?[]const u8 = null, /// Used to store diagnostics from `pushErrorBundle` diff --git a/src/DocumentScope.zig b/src/DocumentScope.zig index 30074163c..cd3a44bec 100644 --- a/src/DocumentScope.zig +++ b/src/DocumentScope.zig @@ -16,7 +16,7 @@ extra: std.ArrayList(u32), /// Every `index` inside this `ArrayhashMap` is equivalent to a `Declaration.Index` /// This means that every declaration is only the child of a single scope -pub const DeclarationLookupMap = std.ArrayHashMapUnmanaged( +pub const DeclarationLookupMap = std.array_hash_map.Custom( DeclarationLookup, void, DeclarationLookupContext, diff --git a/src/DocumentStore.zig b/src/DocumentStore.zig index 182262e7e..e40a9881a 100644 --- a/src/DocumentStore.zig +++ b/src/DocumentStore.zig @@ -26,7 +26,7 @@ mutex: std.Io.Mutex = .init, wait_group: if (supports_build_system) std.Io.Group else void = if (supports_build_system) .init else {}, handles: Uri.ArrayHashMap(*Handle.Future) = .empty, build_files: if (supports_build_system) Uri.ArrayHashMap(*BuildFile) else void = if (supports_build_system) .empty else {}, -cimports: if (supports_build_system) std.AutoArrayHashMapUnmanaged(CImportHash, translate_c.Result) else void = if (supports_build_system) .empty else {}, +cimports: if (supports_build_system) std.array_hash_map.Auto(CImportHash, translate_c.Result) else void = if (supports_build_system) .empty else {}, diagnostics_collection: *DiagnosticsCollection, builds_in_progress: std.atomic.Value(i32) = .init(0), transport: ?*lsp.Transport = null, @@ -361,7 +361,7 @@ pub const Handle = struct { const target_index = modules.getIndex(target_root_source_file).?; // We only care about the root source file of each root module so we convert them to a set. - var root_modules: std.StringArrayHashMapUnmanaged(void) = .empty; + var root_modules: std.array_hash_map.String(void) = .empty; defer root_modules.deinit(allocator); try root_modules.ensureTotalCapacity(allocator, build_config.compilations.len); diff --git a/src/Server.zig b/src/Server.zig index 80e1366ec..7deecdd98 100644 --- a/src/Server.zig +++ b/src/Server.zig @@ -599,12 +599,12 @@ fn initializedHandler(server: *Server, arena: std.mem.Allocator, notification: t if (server.client_capabilities.supports_workspace_did_change_watched_files) { // `{ "watchers": [ { "globPattern": "**/*.{zig,zon}" } ] }` - var watcher: std.json.ObjectMap = .init(arena); - try watcher.putNoClobber("globPattern", .{ .string = "**/*.{zig,zon}" }); + var watcher: std.json.ObjectMap = .empty; + try watcher.putNoClobber(arena, "globPattern", .{ .string = "**/*.{zig,zon}" }); var watchers_arr: std.json.Array = try .initCapacity(arena, 1); watchers_arr.appendAssumeCapacity(.{ .object = watcher }); - var fs_watcher_obj: std.json.ObjectMap = .init(arena); - try fs_watcher_obj.putNoClobber("watchers", .{ .array = watchers_arr }); + var fs_watcher_obj: std.json.ObjectMap = .empty; + try fs_watcher_obj.putNoClobber(arena, "watchers", .{ .array = watchers_arr }); const json_val: std.json.Value = .{ .object = fs_watcher_obj }; try server.registerCapability("workspace/didChangeWatchedFiles", json_val); diff --git a/src/TrigramStore.zig b/src/TrigramStore.zig index 03f0c2c01..9af6114cb 100644 --- a/src/TrigramStore.zig +++ b/src/TrigramStore.zig @@ -27,7 +27,7 @@ pub const Declaration = struct { }; filter_buckets: ?[]CuckooFilter.Bucket, -trigram_to_declarations: std.AutoArrayHashMapUnmanaged(Trigram, std.ArrayList(Declaration.Index)), +trigram_to_declarations: std.array_hash_map.Auto(Trigram, std.ArrayList(Declaration.Index)), declarations: std.MultiArrayList(Declaration), pub fn init( @@ -649,7 +649,7 @@ test CuckooFilter { const element_count = 499; const filter_size = comptime CuckooFilter.capacityForCount(element_count) catch unreachable; - var entries: std.AutoArrayHashMapUnmanaged(Trigram, void) = .empty; + var entries: std.array_hash_map.Auto(Trigram, void) = .empty; defer entries.deinit(allocator); try entries.ensureTotalCapacity(allocator, element_count); diff --git a/src/Uri.zig b/src/Uri.zig index 1cd151e6d..203a3b5c1 100644 --- a/src/Uri.zig +++ b/src/Uri.zig @@ -166,7 +166,7 @@ pub const format = @compileError("Cannot format @import(\"Uri.zig\") directly!. pub const jsonStringify = @compileError("Cannot stringify @import(\"Uri.zig\") directly!. Access the underlying raw string field instead."); pub fn ArrayHashMap(comptime V: type) type { - return std.ArrayHashMapUnmanaged(Uri, V, Context, true); + return std.array_hash_map.Custom(Uri, V, Context, true); } const Context = struct { diff --git a/src/analyser/InternPool.zig b/src/analyser/InternPool.zig index d685551e4..f1f1e0bc4 100644 --- a/src/analyser/InternPool.zig +++ b/src/analyser/InternPool.zig @@ -4,7 +4,7 @@ io: std.Io, gpa: Allocator, -map: std.AutoArrayHashMapUnmanaged(void, void), +map: std.array_hash_map.Auto(void, void), items: std.MultiArrayList(Item), extra: std.ArrayList(u32), string_pool: StringPool, @@ -115,11 +115,11 @@ pub const Key = union(enum) { pub const Function = struct { args: Index.Slice, /// zig only lets the first 32 arguments be `comptime` - args_is_comptime: std.StaticBitSet(32) = .initEmpty(), + args_is_comptime: std.StaticBitSet(32) = .empty, /// zig only lets the first 32 arguments be generic - args_is_generic: std.StaticBitSet(32) = .initEmpty(), + args_is_generic: std.StaticBitSet(32) = .empty, /// zig only lets the first 32 arguments be `noalias` - args_is_noalias: std.StaticBitSet(32) = .initEmpty(), + args_is_noalias: std.StaticBitSet(32) = .empty, return_type: Index, flags: Flags = .{}, @@ -990,7 +990,7 @@ pub const FieldStatus = enum { }; pub const Struct = struct { - fields: std.AutoArrayHashMapUnmanaged(String, Field), + fields: std.array_hash_map.Auto(String, Field), owner_decl: Decl.OptionalIndex, namespace: NamespaceIndex, layout: std.builtin.Type.ContainerLayout = .auto, @@ -1009,8 +1009,8 @@ pub const Struct = struct { pub const Enum = struct { tag_type: InternPool.Index, - fields: std.AutoArrayHashMapUnmanaged(String, void), - values: std.AutoArrayHashMapUnmanaged(InternPool.Index, void), + fields: std.array_hash_map.Auto(String, void), + values: std.array_hash_map.Auto(InternPool.Index, void), namespace: NamespaceIndex, tag_type_inferred: bool, @@ -1019,7 +1019,7 @@ pub const Enum = struct { pub const Union = struct { tag_type: InternPool.Index, - fields: std.AutoArrayHashMapUnmanaged(String, Field), + fields: std.array_hash_map.Auto(String, Field), namespace: NamespaceIndex, layout: std.builtin.Type.ContainerLayout = .auto, status: FieldStatus, @@ -3558,7 +3558,7 @@ pub fn errorSetMerge(ip: *InternPool, a_ty: Index, b_ty: Index) Allocator.Error! const b_names = try ip.indexToKey(b_ty).error_set_type.names.dupe(ip.gpa, ip); defer ip.gpa.free(b_names); - var set: std.AutoArrayHashMapUnmanaged(String, void) = .empty; + var set: std.array_hash_map.Auto(String, void) = .empty; defer set.deinit(ip.gpa); try set.ensureTotalCapacity(ip.gpa, a_names.len + b_names.len); diff --git a/src/analysis.zig b/src/analysis.zig index d2b13b6ee..1c3d9535d 100644 --- a/src/analysis.zig +++ b/src/analysis.zig @@ -2229,7 +2229,7 @@ fn resolveTypeOfNodeUncached(analyser: *Analyser, options: ResolveOptions) Error .error_set_decl => { const lbrace, const rbrace = tree.nodeData(node).token_and_token; - var strings: std.AutoArrayHashMapUnmanaged(InternPool.String, void) = .empty; + var strings: std.array_hash_map.Auto(InternPool.String, void) = .empty; defer strings.deinit(analyser.gpa); var i: usize = 0; for (lbrace + 1..rbrace) |tok_i| { @@ -3852,7 +3852,7 @@ pub const Type = struct { pub const ArraySet = ArrayMap(void); pub fn ArrayMap(comptime V: type) type { - return std.ArrayHashMapUnmanaged(Type, V, ArrayMapContext, true); + return std.array_hash_map.Custom(Type, V, ArrayMapContext, true); } pub const ArrayMapContext = struct { @@ -3931,7 +3931,7 @@ pub const Type = struct { return a_ty.eql(b_ty); } }; - const Deduplicator = std.ArrayHashMapUnmanaged(Type.Data.EitherEntry, void, DeduplicatorContext, true); + const Deduplicator = std.array_hash_map.Custom(Type.Data.EitherEntry, void, DeduplicatorContext, true); var deduplicator: Deduplicator = .empty; defer deduplicator.deinit(arena); @@ -5644,7 +5644,7 @@ pub fn getPositionContext( return .empty; } -pub const TokenToTypeMap = std.ArrayHashMapUnmanaged(TokenWithHandle, Type, TokenWithHandle.Context, true); +pub const TokenToTypeMap = std.array_hash_map.Custom(TokenWithHandle, Type, TokenWithHandle.Context, true); pub const TokenWithHandle = struct { token: Ast.TokenIndex, @@ -6992,7 +6992,7 @@ pub const ReferencedType = struct { return .{ .str = str, .handle = handle, .token = token }; } - pub const Set = std.ArrayHashMapUnmanaged(ReferencedType, void, SetContext, true); + pub const Set = std.array_hash_map.Custom(ReferencedType, void, SetContext, true); const SetContext = struct { pub fn hash(self: SetContext, item: ReferencedType) u32 { diff --git a/src/build_runner/build_runner.zig b/src/build_runner/build_runner.zig index 587098f40..d5e28a04f 100644 --- a/src/build_runner/build_runner.zig +++ b/src/build_runner/build_runner.zig @@ -571,8 +571,8 @@ fn resolveStepNames( b: *std.Build, step_names: []const []const u8, check_step_only: bool, -) !std.AutoArrayHashMapUnmanaged(*Step, void) { - var starting_steps: std.AutoArrayHashMapUnmanaged(*Step, void) = .empty; +) !std.array_hash_map.Auto(*Step, void) { + var starting_steps: std.array_hash_map.Auto(*Step, void) = .empty; errdefer starting_steps.deinit(gpa); if (step_names.len == 0) { @@ -598,7 +598,7 @@ fn resolveStepNames( fn prepare( b: *std.Build, - unpopulated_step_stack: *std.AutoArrayHashMapUnmanaged(*Step, void), + unpopulated_step_stack: *std.array_hash_map.Auto(*Step, void), run: *Run, ) error{ OutOfMemory, DependencyLoopDetected }!void { const gpa = run.gpa; @@ -644,7 +644,7 @@ fn prepare( fn runSteps( b: *std.Build, - step_stack: *const std.AutoArrayHashMapUnmanaged(*Step, void), + step_stack: *const std.array_hash_map.Auto(*Step, void), parent_prog_node: std.Progress.Node, run: *Run, ) (Io.Cancelable || mem.Allocator.Error)!void { @@ -689,7 +689,7 @@ fn constructGraphAndCheckForDependencyLoop( gpa: Allocator, b: *std.Build, s: *Step, - step_stack: *std.AutoArrayHashMapUnmanaged(*Step, void), + step_stack: *std.array_hash_map.Auto(*Step, void), rand: std.Random, ) !void { switch (s.state) { @@ -738,7 +738,7 @@ fn constructGraphAndCheckForDependencyLoop( fn makeStep( group: *Io.Group, b: *std.Build, - steps_stack: *const std.AutoArrayHashMapUnmanaged(*Step, void), + steps_stack: *const std.array_hash_map.Auto(*Step, void), s: *Step, root_prog_node: std.Progress.Node, run: *Run, @@ -837,7 +837,7 @@ fn makeStep( fn stepReady( group: *Io.Group, b: *std.Build, - steps_stack: *const std.AutoArrayHashMapUnmanaged(*Step, void), + steps_stack: *const std.array_hash_map.Auto(*Step, void), s: *Step, root_prog_node: std.Progress.Node, run: *Run, @@ -903,7 +903,7 @@ fn validateSystemLibraryOptions(b: *std.Build) void { fn createModuleDependencies(b: *std.Build) Allocator.Error!void { const arena = b.graph.arena; - var all_steps: std.AutoArrayHashMapUnmanaged(*Step, void) = .empty; + var all_steps: std.array_hash_map.Auto(*Step, void) = .empty; var next_step_idx: usize = 0; try all_steps.ensureUnusedCapacity(arena, b.top_level_steps.count()); @@ -993,13 +993,13 @@ fn extractBuildInformation( run: *Run, ) !void { const helper = struct { - fn addLazyPathStepDependencies(allocator: Allocator, set: *std.AutoArrayHashMapUnmanaged(*Step, void), lazy_path: std.Build.LazyPath) !void { + fn addLazyPathStepDependencies(allocator: Allocator, set: *std.array_hash_map.Auto(*Step, void), lazy_path: std.Build.LazyPath) !void { switch (lazy_path) { .src_path, .cwd_relative, .dependency => {}, .generated => |gen| try set.put(allocator, gen.file.step, {}), } } - fn addIncludeDirStepDependencies(allocator: Allocator, set: *std.AutoArrayHashMapUnmanaged(*Step, void), include_dir: std.Build.Module.IncludeDir) !void { + fn addIncludeDirStepDependencies(allocator: Allocator, set: *std.array_hash_map.Auto(*Step, void), include_dir: std.Build.Module.IncludeDir) !void { switch (include_dir) { .path, .path_system, @@ -1022,7 +1022,7 @@ fn extractBuildInformation( } } /// Only adds the necessary dependencies to resolve the `root_source_file` and `include_dirs`. Does not include dependencies of imported modules. - fn addModuleDependencies(allocator: Allocator, set: *std.AutoArrayHashMapUnmanaged(*Step, void), module: *std.Build.Module) !void { + fn addModuleDependencies(allocator: Allocator, set: *std.array_hash_map.Auto(*Step, void), module: *std.Build.Module) !void { if (module.root_source_file) |root_source_file| { try addLazyPathStepDependencies(allocator, set, root_source_file); } @@ -1033,14 +1033,14 @@ fn extractBuildInformation( } fn processModule( allocator: Allocator, - modules: *std.StringArrayHashMapUnmanaged(shared.BuildConfig.Module), + modules: *std.array_hash_map.String(shared.BuildConfig.Module), module: *std.Build.Module, compile: ?*Step.Compile, ) !void { const root_source_file = module.root_source_file orelse return; - var include_dirs: std.StringArrayHashMapUnmanaged(void) = .empty; - var c_macros: std.StringArrayHashMapUnmanaged(void) = .empty; + var include_dirs: std.array_hash_map.String(void) = .empty; + var c_macros: std.array_hash_map.String(void) = .empty; if (compile) |exe| { try processPkgConfig(allocator, &include_dirs, &c_macros, exe); @@ -1115,7 +1115,7 @@ fn extractBuildInformation( const gpa = run.gpa; // The value tracks whether the step is a decendant of the "install" step. - var all_steps: std.AutoArrayHashMapUnmanaged(*Step, bool) = .empty; + var all_steps: std.array_hash_map.Auto(*Step, bool) = .empty; defer all_steps.deinit(gpa); // collect all steps that are decendants of the "install" step. @@ -1154,10 +1154,10 @@ fn extractBuildInformation( // Collect all steps that need to be run so that we can resolve the lazy paths we are interested in (e.g. root_source_file). { - var needed_steps: std.AutoArrayHashMapUnmanaged(*Step, void) = .empty; + var needed_steps: std.array_hash_map.Auto(*Step, void) = .empty; defer needed_steps.deinit(gpa); - var modules: std.AutoArrayHashMapUnmanaged(*std.Build.Module, void) = .empty; + var modules: std.array_hash_map.Auto(*std.Build.Module, void) = .empty; defer modules.deinit(gpa); try modules.ensureUnusedCapacity(gpa, b.modules.count()); @@ -1195,7 +1195,7 @@ fn extractBuildInformation( // - public modules (`std.Build.addModule`) // - modules that are reachable from the "install" step // - all other reachable modules - var modules: std.StringArrayHashMapUnmanaged(BuildConfig.Module) = .empty; + var modules: std.array_hash_map.String(BuildConfig.Module) = .empty; for (b.modules.values()) |root_module| { const graph = root_module.getGraph(); @@ -1242,7 +1242,7 @@ fn extractBuildInformation( // }; // Collect the dependencies from `build.zig.zon` - var root_dependencies: std.StringArrayHashMapUnmanaged([]const u8) = .empty; + var root_dependencies: std.array_hash_map.String([]const u8) = .empty; for (dependencies.root_deps) |root_dep| { inline for (comptime std.meta.declarations(dependencies.packages)) |package| blk: { if (std.mem.eql(u8, package.name, root_dep[1])) { @@ -1258,7 +1258,7 @@ fn extractBuildInformation( } } - var available_options: std.StringArrayHashMapUnmanaged(BuildConfig.AvailableOption) = .empty; + var available_options: std.array_hash_map.String(BuildConfig.AvailableOption) = .empty; try available_options.ensureTotalCapacity(arena, b.available_options_map.count()); var it = b.available_options_map.iterator(); @@ -1284,8 +1284,8 @@ fn extractBuildInformation( fn processPkgConfig( allocator: Allocator, - include_dirs: *std.StringArrayHashMapUnmanaged(void), - c_macros: *std.StringArrayHashMapUnmanaged(void), + include_dirs: *std.array_hash_map.String(void), + c_macros: *std.array_hash_map.String(void), exe: *Step.Compile, ) !void { for (exe.root_module.link_objects.items) |link_object| { diff --git a/src/features/code_actions.zig b/src/features/code_actions.zig index acd3111c2..d01ad553b 100644 --- a/src/features/code_actions.zig +++ b/src/features/code_actions.zig @@ -835,7 +835,7 @@ pub fn getImportsDecls(builder: *Builder, allocator: std.mem.Allocator) error{Ou var skip_set: std.DynamicBitSetUnmanaged = try .initEmpty(allocator, root_decls.len); defer skip_set.deinit(allocator); - var imports: std.ArrayHashMapUnmanaged(ImportDecl, void, void, true) = .empty; + var imports: std.array_hash_map.Custom(ImportDecl, void, void, true) = .empty; defer imports.deinit(allocator); // iterate until no more imports are found diff --git a/src/features/completions.zig b/src/features/completions.zig index 3cdb6c1f8..09b6a5779 100644 --- a/src/features/completions.zig +++ b/src/features/completions.zig @@ -30,7 +30,7 @@ const Builder = struct { }; pub const Completions = struct { - map: std.StringArrayHashMapUnmanaged(types.completion.Item), + map: std.array_hash_map.String(types.completion.Item), pub const empty: Completions = .{ .map = .empty }; diff --git a/src/features/diagnostics.zig b/src/features/diagnostics.zig index 0c7f2bb3c..58aac91c1 100644 --- a/src/features/diagnostics.zig +++ b/src/features/diagnostics.zig @@ -626,7 +626,7 @@ pub const BuildOnSave = struct { const stdout = multi_reader.reader(0); const stderr = multi_reader.reader(1); - var diagnostic_tags: std.AutoArrayHashMapUnmanaged(DiagnosticsCollection.Tag, void) = .empty; + var diagnostic_tags: std.array_hash_map.Auto(DiagnosticsCollection.Tag, void) = .empty; defer diagnostic_tags.deinit(allocator); defer { @@ -711,7 +711,7 @@ pub const BuildOnSave = struct { body: []u8, collection: *DiagnosticsCollection, workspace_path: []const u8, - diagnostic_tags: *std.AutoArrayHashMapUnmanaged(DiagnosticsCollection.Tag, void), + diagnostic_tags: *std.array_hash_map.Auto(DiagnosticsCollection.Tag, void), ) (error{ OutOfMemory, InvalidMessage } || std.Io.File.Writer.Error)!void { var reader: std.Io.Reader = .fixed(body); diff --git a/src/features/references.zig b/src/features/references.zig index 44542d5ab..7e59ac821 100644 --- a/src/features/references.zig +++ b/src/features/references.zig @@ -757,7 +757,7 @@ pub fn referencesHandler(server: *Server, arena: std.mem.Allocator, request: Gen switch (request) { .rename => |rename| { const escaped_rename = try std.fmt.allocPrint(arena, "{f}", .{std.zig.fmtId(rename.newName)}); - var changes: std.StringArrayHashMapUnmanaged(std.ArrayList(types.TextEdit)) = .empty; + var changes: std.array_hash_map.String(std.ArrayList(types.TextEdit)) = .empty; for (locations.items) |loc| { const gop = try changes.getOrPutValue(arena, loc.uri, .empty); diff --git a/tests/ErrorBuilder.zig b/tests/ErrorBuilder.zig index 0eb95de7b..b4cebee2c 100644 --- a/tests/ErrorBuilder.zig +++ b/tests/ErrorBuilder.zig @@ -9,7 +9,7 @@ const ErrorBuilder = @This(); allocator: std.mem.Allocator, encoding: offsets.Encoding = .@"utf-16", -files: std.StringArrayHashMapUnmanaged(File) = .empty, +files: std.array_hash_map.String(File) = .empty, message_count: usize = 0, /// similar to `git diff --unified` /// show error messages with n lines of context. diff --git a/tests/lsp_features/completion.zig b/tests/lsp_features/completion.zig index 2139ef12f..4ba071b0a 100644 --- a/tests/lsp_features/completion.zig +++ b/tests/lsp_features/completion.zig @@ -453,10 +453,10 @@ test "std.ArrayList" { }); } -test "std.ArrayHashMap" { +test "std.array_hash_map" { try testCompletion( \\const std = @import("std"); - \\const map: std.StringArrayHashMapUnmanaged(void) = undefined; + \\const map: std.array_hash_map.String(void) = undefined; \\const key = map.getKey(""); \\const foo = key.?. , &.{ @@ -466,7 +466,7 @@ test "std.ArrayHashMap" { try testCompletion( \\const std = @import("std"); \\const S = struct { alpha: u32 }; - \\const map: std.AutoArrayHashMapUnmanaged(u32, S) = undefined; + \\const map: std.array_hash_map.Auto(u32, S) = undefined; \\const s = map.get(0); \\const foo = s.?. , &.{ @@ -475,7 +475,7 @@ test "std.ArrayHashMap" { try testCompletion( \\const std = @import("std"); \\const S = struct { alpha: u32 }; - \\const map: std.AutoArrayHashMapUnmanaged(u32, S) = undefined; + \\const map: std.array_hash_map.Auto(u32, S) = undefined; \\const gop = try map.getOrPut(undefined, 0); \\const foo = gop.value_ptr. , &.{ @@ -4926,8 +4926,8 @@ fn testCompletionWithOptions( } } -fn extractCompletionLabels(items: anytype) error{ DuplicateCompletionLabel, OutOfMemory }!std.StringArrayHashMapUnmanaged(void) { - var set: std.StringArrayHashMapUnmanaged(void) = .empty; +fn extractCompletionLabels(items: anytype) error{ DuplicateCompletionLabel, OutOfMemory }!std.array_hash_map.String(void) { + var set: std.array_hash_map.String(void) = .empty; errdefer set.deinit(allocator); try set.ensureTotalCapacity(allocator, items.len); for (items) |item| { @@ -4946,8 +4946,8 @@ fn extractCompletionLabels(items: anytype) error{ DuplicateCompletionLabel, OutO return set; } -fn set_intersection(a: std.StringArrayHashMapUnmanaged(void), b: std.StringArrayHashMapUnmanaged(void)) error{OutOfMemory}!std.StringArrayHashMapUnmanaged(void) { - var result: std.StringArrayHashMapUnmanaged(void) = .empty; +fn set_intersection(a: std.array_hash_map.String(void), b: std.array_hash_map.String(void)) error{OutOfMemory}!std.array_hash_map.String(void) { + var result: std.array_hash_map.String(void) = .empty; errdefer result.deinit(allocator); for (a.keys()) |key| { if (b.contains(key)) try result.putNoClobber(allocator, key, {}); @@ -4955,8 +4955,8 @@ fn set_intersection(a: std.StringArrayHashMapUnmanaged(void), b: std.StringArray return result; } -fn set_difference(a: std.StringArrayHashMapUnmanaged(void), b: std.StringArrayHashMapUnmanaged(void)) error{OutOfMemory}!std.StringArrayHashMapUnmanaged(void) { - var result: std.StringArrayHashMapUnmanaged(void) = .empty; +fn set_difference(a: std.array_hash_map.String(void), b: std.array_hash_map.String(void)) error{OutOfMemory}!std.array_hash_map.String(void) { + var result: std.array_hash_map.String(void) = .empty; errdefer result.deinit(allocator); for (a.keys()) |key| { if (!b.contains(key)) try result.putNoClobber(allocator, key, {}); @@ -4964,7 +4964,7 @@ fn set_difference(a: std.StringArrayHashMapUnmanaged(void), b: std.StringArrayHa return result; } -fn printLabels(output: *std.ArrayList(u8), labels: std.StringArrayHashMapUnmanaged(void), name: []const u8) error{OutOfMemory}!void { +fn printLabels(output: *std.ArrayList(u8), labels: std.array_hash_map.String(void), name: []const u8) error{OutOfMemory}!void { if (labels.count() != 0) { try output.print(allocator, "{s}:\n", .{name}); for (labels.keys()) |label| { diff --git a/tests/lsp_features/references.zig b/tests/lsp_features/references.zig index c251595e8..f51f4e1cd 100644 --- a/tests/lsp_features/references.zig +++ b/tests/lsp_features/references.zig @@ -364,13 +364,13 @@ fn testMultiFileSymbolReferences(sources: []const []const u8, include_decl: bool const File = struct { source: []const u8, new_source: []const u8 }; const LocPair = struct { file_index: usize, old: offsets.Loc, new: offsets.Loc }; - var files: std.StringArrayHashMapUnmanaged(File) = .empty; + var files: std.array_hash_map.String(File) = .empty; defer { for (files.values()) |file| allocator.free(file.new_source); files.deinit(allocator); } - var loc_set: std.StringArrayHashMapUnmanaged(std.MultiArrayList(LocPair)) = .empty; + var loc_set: std.array_hash_map.String(std.MultiArrayList(LocPair)) = .empty; defer { for (loc_set.values()) |*locs| locs.deinit(allocator); loc_set.deinit(allocator); From cb67164849e4410e7805028669091e70d3f953d1 Mon Sep 17 00:00:00 2001 From: Techatrix Date: Tue, 14 Apr 2026 01:10:35 +0200 Subject: [PATCH 02/14] update usage of deprecated `std.StaticBitSet.initEmpty` --- src/analyser/InternPool.zig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/analyser/InternPool.zig b/src/analyser/InternPool.zig index f1f1e0bc4..03b372049 100644 --- a/src/analyser/InternPool.zig +++ b/src/analyser/InternPool.zig @@ -4688,9 +4688,9 @@ test "function type" { .return_type = .bool_type, } }); - var args_is_comptime: std.StaticBitSet(32) = .initEmpty(); + var args_is_comptime: std.StaticBitSet(32) = .empty; args_is_comptime.set(0); - var args_is_noalias: std.StaticBitSet(32) = .initEmpty(); + var args_is_noalias: std.StaticBitSet(32) = .empty; args_is_noalias.set(1); const @"fn(comptime type, noalias i32) type" = try ip.get(.{ .function_type = .{ From 1c2a27922b627b5d86528e364fc7cf007d14827a Mon Sep 17 00:00:00 2001 From: Techatrix Date: Tue, 14 Apr 2026 01:11:05 +0200 Subject: [PATCH 03/14] `dumpStackTrace` -> `dumpErrorReturnTrace` --- src/Server.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Server.zig b/src/Server.zig index 7deecdd98..b7d48eb2b 100644 --- a/src/Server.zig +++ b/src/Server.zig @@ -1894,7 +1894,7 @@ fn processMessageReportError(server: *Server, arena_state: std.heap.ArenaAllocat if (err == error.Canceled) return error.Canceled; log.err("failed to process {f}: {}", .{ fmtMessage(message), err }); if (@errorReturnTrace()) |trace| { - std.debug.dumpStackTrace(trace); + std.debug.dumpErrorReturnTrace(trace); } switch (message) { From bbac5ead803210a08bc0ccfd52694e072514d6f5 Mon Sep 17 00:00:00 2001 From: Techatrix Date: Tue, 14 Apr 2026 01:09:30 +0200 Subject: [PATCH 04/14] update langref.html.in --- src/tools/langref.html.in | 384 +++++++++++++++++++----------- tests/lsp_features/completion.zig | 4 +- 2 files changed, 250 insertions(+), 138 deletions(-) diff --git a/src/tools/langref.html.in b/src/tools/langref.html.in index c0272124c..6f11bc006 100644 --- a/src/tools/langref.html.in +++ b/src/tools/langref.html.in @@ -128,6 +128,7 @@ } .table-wrapper { width: 100%; + margin: 1em auto; overflow-x: auto; } @@ -318,6 +319,7 @@ 0.13.0 | 0.14.1 | 0.15.2 | + 0.16.0 | master