reduce size of TrigramStore.Declaration

Author: Techatrix

src/Server.zig

@@ -1524,43 +1524,54 @@ fn workspaceSymbolHandler(server: *Server, arena: std.mem.Allocator, request: ty
 
     var symbols: std.ArrayListUnmanaged(types.WorkspaceSymbol) = .empty;
     var declaration_buffer: std.ArrayListUnmanaged(TrigramStore.Declaration.Index) = .empty;
-    var loc_buffer: std.ArrayListUnmanaged(offsets.Loc) = .empty;
-    var range_buffer: std.ArrayListUnmanaged(offsets.Range) = .empty;
 
     for (handles) |handle| {
         const trigram_store = handle.getTrigramStoreCached();
 
         declaration_buffer.clearRetainingCapacity();
         try trigram_store.declarationsForQuery(arena, request.query, &declaration_buffer);
 
+        const SortContext = struct {
+            names: []const std.zig.Ast.TokenIndex,
+            fn lessThan(ctx: @This(), lhs: TrigramStore.Declaration.Index, rhs: TrigramStore.Declaration.Index) bool {
+                return ctx.names[@intFromEnum(lhs)] < ctx.names[@intFromEnum(rhs)];
+            }
+        };
+
+        std.mem.sortUnstable(
+            TrigramStore.Declaration.Index,
+            declaration_buffer.items,
+            SortContext{ .names = trigram_store.declarations.items(.name) },
+            SortContext.lessThan,
+        );
+
         const slice = trigram_store.declarations.slice();
         const names = slice.items(.name);
-        const locs = slice.items(.loc);
 
-        {
-            // Convert `offsets.Loc` to `offsets.Range`
+        var last_index: usize = 0;
+        var last_position: offsets.Position = .{ .line = 0, .character = 0 };
 
-            try loc_buffer.resize(arena, declaration_buffer.items.len);
-            try range_buffer.resize(arena, declaration_buffer.items.len);
+        try symbols.ensureUnusedCapacity(arena, declaration_buffer.items.len);
+        for (declaration_buffer.items) |declaration| {
+            const name_token = names[@intFromEnum(declaration)];
+            const loc = offsets.identifierTokenToNameLoc(handle.tree, name_token);
+            const name = offsets.identifierTokenToNameSlice(handle.tree, name_token);
 
-            for (declaration_buffer.items, loc_buffer.items) |declaration, *loc| {
-                const small_loc = locs[@intFromEnum(declaration)];
-                loc.* = .{ .start = small_loc.start, .end = small_loc.end };
-            }
+            const start_position = offsets.advancePosition(handle.tree.source, last_position, last_index, loc.start, server.offset_encoding);
+            const end_position = offsets.advancePosition(handle.tree.source, start_position, loc.start, loc.end, server.offset_encoding);
+            last_index = loc.end;
+            last_position = end_position;
 
-            try offsets.multiple.locToRange(arena, handle.tree.source, loc_buffer.items, range_buffer.items, server.offset_encoding);
-        }
-
-        try symbols.ensureUnusedCapacity(arena, declaration_buffer.items.len);
-        for (declaration_buffer.items, range_buffer.items) |declaration, range| {
-            const name = names[@intFromEnum(declaration)];
             symbols.appendAssumeCapacity(.{
-                .name = trigram_store.names.items[name.start..name.end],
+                .name = name,
                 .kind = .Variable,
                 .location = .{
                     .Location = .{
                         .uri = handle.uri,
-                        .range = range,
+                        .range = .{
+                            .start = start_position,
+                            .end = end_position,
+                        },
                     },
                 },
             });

src/TrigramStore.zig

@@ -10,14 +10,10 @@ pub const TrigramStore = @This();
 
 pub const Trigram = [3]u8;
 
-pub const NameSlice = struct { start: u32, end: u32 };
-pub const Loc = struct { start: u32, end: u32 };
-
 pub const Declaration = struct {
     pub const Index = enum(u32) { _ };
 
-    name: NameSlice,
-    loc: Loc,
+    name: Ast.TokenIndex,
 };
 
 has_filter: bool,
@@ -55,7 +51,6 @@ pub fn init(
                 .fn_proto_multi,
                 .fn_proto_one,
                 .fn_proto_simple,
-                .fn_decl,
                 => |tag| skip: {
                     context.in_function = tag == .fn_decl;
 
@@ -90,15 +85,11 @@ pub fn init(
                 else => {},
             }
 
-            if (name_token_maybe) |name_token| skip: {
-                const loc = offsets.tokenToLoc(cb_tree, name_token);
-                const name = offsets.locToSlice(cb_tree.source, loc);
-                if (name.len < 3) break :skip;
-
+            if (name_token_maybe) |name_token| {
                 try context.store.appendDeclaration(
                     context.allocator,
-                    name,
-                    .{ .start = @intCast(loc.start), .end = @intCast(loc.end) },
+                    cb_tree,
+                    name_token,
                 );
             }
 
@@ -166,23 +157,15 @@ pub fn deinit(store: *TrigramStore, allocator: std.mem.Allocator) void {
 fn appendDeclaration(
     store: *TrigramStore,
     allocator: std.mem.Allocator,
-    name: []const u8,
-    loc: Loc,
+    tree: Ast,
+    name_token: Ast.TokenIndex,
 ) error{OutOfMemory}!void {
-    assert(name.len >= 3);
-
-    const name_slice: NameSlice = blk: {
-        const start = store.names.items.len;
-        try store.names.appendSlice(allocator, name);
-        break :blk .{
-            .start = @intCast(start),
-            .end = @intCast(store.names.items.len),
-        };
-    };
+    const loc = offsets.identifierTokenToNameLoc(tree, name_token);
+    const name = offsets.locToSlice(tree.source, loc);
+    if (name.len < 3) return;
 
     try store.declarations.append(allocator, .{
-        .name = name_slice,
-        .loc = loc,
+        .name = name_token,
     });
 
     for (0..name.len - 2) |index| {