safety related fixes

src/analysis.zig

@@ -46,6 +46,7 @@
     self.bound_type_params.deinit(self.gpa);
     self.resolved_callsites.deinit(self.gpa);
     self.resolved_nodes.deinit(self.gpa);
+    std.debug.assert(self.use_trail.count() == 0);
     self.use_trail.deinit(self.gpa);
     self.arena.deinit();
 }
@@ -493,6 +494,7 @@
     const resolved = switch (node_tags[node_handle.node]) {
         .identifier => blk: {
             const name_token = main_tokens[node_handle.node];
+            if (tree.tokens.items(.tag)[name_token] != .identifier) break :blk null;
             const name = offsets.identifierTokenToNameSlice(tree, name_token);
             break :blk try analyser.lookupSymbolGlobal(
                 handle,
@@ -1871,7 +1873,10 @@
             .error_union,
             .union_tag,
             => |t| t.hashWithHasher(hasher),
-            .other => |idx| std.hash.autoHash(hasher, idx),
+            .other => |node_handle| {
+                std.hash.autoHash(hasher, node_handle.node);
+                hasher.update(node_handle.handle.uri);
+            },
             .either => |entries| {
                 for (entries) |entry| {
                     hasher.update(entry.descriptor);
@@ -2466,7 +2471,10 @@
             return if (field.tuple_like) null else tree.tokenSlice(field.main_token);
         },
         .error_value => tree.tokenSlice(data[node].rhs),
-        .identifier => offsets.identifierTokenToNameSlice(tree, main_token),
+        .identifier => {
+            if (tree.tokens.items(.tag)[main_token] != .identifier) return null;
+            return offsets.identifierTokenToNameSlice(tree, main_token);
+        },
         .fn_proto,
         .fn_proto_multi,
         .fn_proto_one,
@@ -3182,7 +3190,7 @@
     } else null;
 }
 
-fn iterateSymbolsContainerInternal(
+pub fn iterateSymbolsContainer(
     analyser: *Analyser,
     container_handle: NodeWithHandle,
     orig_handle: *DocumentStore.Handle,
@@ -3269,6 +3277,7 @@
 ) !void {
     const gop = try analyser.use_trail.getOrPut(analyser.gpa, .{ .node = usingnamespace_node.node, .uri = usingnamespace_node.handle.uri });
     if (gop.found_existing) return;
+    defer std.debug.assert(analyser.use_trail.remove(.{ .node = usingnamespace_node.node, .uri = usingnamespace_node.handle.uri }));
 
     const handle = usingnamespace_node.handle;
     const tree = handle.tree;
@@ -3284,7 +3293,7 @@
 
     switch (use_expr.data) {
         .other => |expr| {
-            try analyser.iterateSymbolsContainerInternal(
+            try analyser.iterateSymbolsContainer(
                 expr,
                 orig_handle,
                 callback,
@@ -3296,7 +3305,7 @@
             for (entries) |entry| {
                 switch (entry.type_with_handle.data) {
                     .other => |expr| {
-                        try analyser.iterateSymbolsContainerInternal(
+                        try analyser.iterateSymbolsContainer(
                             expr,
                             orig_handle,
                             callback,
@@ -3339,18 +3348,6 @@
     };
 }
 
-pub fn iterateSymbolsContainer(
-    analyser: *Analyser,
-    container_handle: NodeWithHandle,
-    orig_handle: *DocumentStore.Handle,
-    comptime callback: anytype,
-    context: anytype,
-    instance_access: bool,
-) error{OutOfMemory}!void {
-    analyser.use_trail.clearRetainingCapacity();
-    return try analyser.iterateSymbolsContainerInternal(container_handle, orig_handle, callback, context, instance_access);
-}
-
 pub fn iterateLabels(handle: *DocumentStore.Handle, source_index: usize, comptime callback: anytype, context: anytype) error{OutOfMemory}!void {
     const document_scope = try handle.getDocumentScope();
     var scope_iterator = iterateEnclosingScopes(&document_scope, source_index);
@@ -3449,10 +3446,10 @@
 }
 
 fn resolveUse(analyser: *Analyser, uses: []const Ast.Node.Index, symbol: []const u8, handle: *DocumentStore.Handle) error{OutOfMemory}!?DeclWithHandle {
-    analyser.use_trail.clearRetainingCapacity();
     for (uses) |index| {
         const gop = try analyser.use_trail.getOrPut(analyser.gpa, .{ .node = index, .uri = handle.uri });
         if (gop.found_existing) continue;
+        defer std.debug.assert(analyser.use_trail.remove(.{ .node = index, .uri = handle.uri }));
 
         const tree = handle.tree;
         if (tree.nodes.items(.data).len <= index) continue;
@@ -4360,6 +4357,7 @@
                 const tree = handle.tree;
 
                 const name_token = tree.nodes.items(.main_token)[node];
+                if (tree.tokens.items(.tag)[name_token] != .identifier) return null;
                 const name = offsets.identifierTokenToNameSlice(tree, name_token);
                 const is_escaped_identifier = tree.source[tree.tokens.items(.start)[name_token]] == '@';
                 if (is_escaped_identifier) return null;

src/features/inlay_hints.zig

@@ -300,7 +300,7 @@ fn writeForCaptureHint(builder: *Builder, for_node: Ast.Node.Index) !void {
     defer tracy_zone.end();
 
     const tree = builder.handle.tree;
-    const full_for = tree.fullFor(for_node).?;
+    const full_for = ast.fullFor(tree, for_node).?;
     const token_tags = tree.tokens.items(.tag);
     var capture_token = full_for.payload_token;
     for (full_for.ast.inputs) |_| {

src/main.zig

@@ -102,7 +102,12 @@ fn updateConfig(
         const json_message = try transport.readJsonMessage(allocator);
         defer allocator.free(json_message);
 
-        const new_config = try std.json.parseFromSlice(Config, allocator, json_message, .{});
+        const new_config = try std.json.parseFromSlice(
+            Config,
+            allocator,
+            json_message,
+            .{ .allocate = .alloc_always },
+        );
         defer allocator.destroy(new_config.arena);
         config.arena.promote(allocator).deinit();
         config.arena = new_config.arena.state;

tests/lsp_features/semantic_tokens.zig

@@ -1626,6 +1626,22 @@ test "semantic tokens - assembly" {
     });
 }
 
+test "semantic tokens - recursive usingnamespace" {
+    // this test is supposed to check against infinite recursion when resolving usingnamespace
+    try testSemanticTokens(
+        \\const A = struct {
+        \\    usingnamespace A;
+        \\};
+    , &.{
+        .{ "const", .keyword, .{} },
+        .{ "A", .namespace, .{ .declaration = true } },
+        .{ "=", .operator, .{} },
+        .{ "struct", .keyword, .{} },
+        .{ "usingnamespace", .keyword, .{} },
+        .{ "A", .namespace, .{} },
+    });
+}
+
 test "semantic tokens - weird code" {
     // the expected output is irrelevant, just ensure no crash
     try testSemanticTokens(