move Loc to Position conversion out of TrigramStore

Author: Techatrix

src/DocumentStore.zig

@@ -346,7 +346,7 @@ pub const Handle = struct {
         if (self.getStatus().has_trigram_store) return self.impl.trigram_store;
         return try self.getLazy(TrigramStore, "trigram_store", struct {
             fn create(handle: *Handle, allocator: std.mem.Allocator) error{OutOfMemory}!TrigramStore {
-                return try .init(allocator, handle.tree, .@"utf-16"); // TODO
+                return try .init(allocator, handle.tree);
             }
         });
     }

src/Server.zig

@@ -1986,6 +1986,8 @@ 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();
@@ -1995,12 +1997,25 @@ fn workspaceSymbolHandler(server: *Server, arena: std.mem.Allocator, request: ty
 
         const slice = trigram_store.declarations.slice();
         const names = slice.items(.name);
-        const ranges = slice.items(.range);
+        const locs = slice.items(.loc);
+
+        {
+            // Convert `offsets.Loc` to `offsets.Range`
+
+            try loc_buffer.resize(arena, declaration_buffer.items.len);
+            try range_buffer.resize(arena, declaration_buffer.items.len);
+
+            for (declaration_buffer.items, loc_buffer.items) |declaration, *loc| {
+                const small_loc = locs[@intFromEnum(declaration)];
+                loc.* = .{ .start = small_loc.start, .end = small_loc.end };
+            }
+
+            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) |declaration| {
+        for (declaration_buffer.items, range_buffer.items) |declaration, range| {
             const name = names[@intFromEnum(declaration)];
-            const range = ranges[@intFromEnum(declaration)];
             symbols.appendAssumeCapacity(.{
                 .name = trigram_store.names.items[name.start..name.end],
                 .kind = .Variable,

src/TrigramStore.zig

@@ -14,12 +14,13 @@ 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,
-    range: offsets.Range,
+    loc: Loc,
 };
 
 has_filter: bool,
@@ -31,7 +32,6 @@ names: std.ArrayListUnmanaged(u8),
 pub fn init(
     allocator: std.mem.Allocator,
     tree: Ast,
-    encoding: offsets.Encoding,
 ) error{OutOfMemory}!TrigramStore {
     var store: TrigramStore = .{
         .has_filter = false,
@@ -46,7 +46,6 @@ pub fn init(
         allocator: std.mem.Allocator,
         store: *TrigramStore,
         in_function: bool,
-        encoding: offsets.Encoding,
 
         const Error = error{OutOfMemory};
         fn callback(context: *@This(), cb_tree: Ast, node: Ast.Node.Index) Error!void {
@@ -84,10 +83,12 @@ pub fn init(
                         const name = cb_tree.tokenSlice(token);
 
                         if (name.len >= 3) {
+                            const loc = offsets.tokenToLoc(cb_tree, token);
+
                             try context.store.appendDeclaration(
                                 context.allocator,
                                 name,
-                                offsets.tokenToRange(cb_tree, token, context.encoding),
+                                .{ .start = @intCast(loc.start), .end = @intCast(loc.end) },
                             );
                         }
                     }
@@ -104,7 +105,6 @@ pub fn init(
         .allocator = allocator,
         .store = &store,
         .in_function = false,
-        .encoding = encoding,
     };
     try ast.iterateChildren(tree, .root, &context, Context.Error, Context.callback);
 
@@ -162,7 +162,7 @@ fn appendDeclaration(
     store: *TrigramStore,
     allocator: std.mem.Allocator,
     name: []const u8,
-    range: offsets.Range,
+    loc: Loc,
 ) error{OutOfMemory}!void {
     assert(name.len >= 3);
 
@@ -177,7 +177,7 @@ fn appendDeclaration(
 
     try store.declarations.append(allocator, .{
         .name = name_slice,
-        .range = range,
+        .loc = loc,
     });
 
     for (0..name.len - 2) |index| {