bug hunting

src/ComptimeInterpreter.zig

@@ -46,15 +46,19 @@ pub fn recordError(
     comptime fmt: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
-    try interpreter.errors.put(interpreter.allocator, node_idx, .{
+    const message = try std.fmt.allocPrint(interpreter.allocator, fmt, args);
+    errdefer interpreter.allocator.free(message);
+    const previous = try interpreter.errors.fetchPut(interpreter.allocator, node_idx, .{
         .code = code,
-        .message = try std.fmt.allocPrint(interpreter.allocator, fmt, args),
+        .message = message,
     });
+    if (previous != null) interpreter.allocator.free(message);
 }
 
 pub fn deinit(interpreter: *ComptimeInterpreter) void {
-    var err_it = interpreter.errors.iterator();
+    for (interpreter.errors.values()) |err| {
-    while (err_it.next()) |entry| interpreter.allocator.free(entry.value_ptr.message);
+        interpreter.allocator.free(err.message);
+    }
 
     interpreter.errors.deinit(interpreter.allocator);
     interpreter.ip.deinit(interpreter.allocator);
@@ -302,8 +306,8 @@ pub fn interpret(
 
             const decl = ast.varDecl(tree, node_idx).?;
 
-            const type_value = if (decl.ast.type_node != 0) try ((try interpreter.interpret(decl.ast.type_node, namespace, .{})).getValue()) else null;
+            const type_value = if (decl.ast.type_node != 0) (try interpreter.interpret(decl.ast.type_node, namespace, .{})).maybeGetValue() else null;
-            const init_value = if (decl.ast.init_node != 0) try ((try interpreter.interpret(decl.ast.init_node, namespace, .{})).getValue()) else null;
+            const init_value = if (decl.ast.init_node != 0) (try interpreter.interpret(decl.ast.init_node, namespace, .{})).maybeGetValue() else null;
 
             if (type_value == null and init_value == null) return InterpretResult{ .nothing = {} };
 
@@ -470,6 +474,8 @@ pub fn interpret(
             const can_have_fields: bool = switch (inner_lhs) {
                 .simple => |simple| switch (simple) {
                     .type => blk: {
+                        if (irv.val == .none) break :blk true;
+
                         const ty_key = interpreter.ip.indexToKey(irv.val);
                         if (interpreter.huntItDown(ty_key.getNamespace(), field_name, options)) |decl| {
                             return InterpretResult{ .value = Value{

src/DocumentStore.zig

@@ -68,6 +68,10 @@ pub const Handle = struct {
     associated_build_file: ?Uri = null,
 
     pub fn deinit(self: *Handle, allocator: std.mem.Allocator) void {
+        if (self.interpreter) |interpreter| {
+            interpreter.deinit();
+            allocator.destroy(interpreter);
+        }
         self.document_scope.deinit(allocator);
         self.tree.deinit(allocator);
         allocator.free(self.text);

src/Server.zig

@@ -361,7 +361,7 @@ fn generateDiagnostics(server: *Server, handle: DocumentStore.Handle) error{OutO
         var err_it = int.errors.iterator();
 
         while (err_it.next()) |err| {
-            try diagnostics.append(allocator, .{
+            diagnostics.appendAssumeCapacity(.{
                 .range = offsets.nodeToRange(tree, err.key_ptr.*, server.offset_encoding),
                 .severity = .Error,
                 .code = .{ .string = err.value_ptr.code },

src/analyser/InternPool.zig

@@ -321,7 +321,8 @@ pub const Key = union(enum) {
                 .@"anyframe",
                 .null_type,
                 .undefined_type,
-                .enum_literal_type, => true,
+                .enum_literal_type,
+                => true,
 
                 .undefined_value,
                 .void_value,
@@ -344,7 +345,8 @@ pub const Key = union(enum) {
             .union_type,
             .tuple_type,
             .vector_type,
-            .anyframe_type, => true,
+            .anyframe_type,
+            => true,
 
             .int_u64_value,
             .int_i64_value,

src/analyser/completions.zig

@@ -10,7 +10,7 @@ pub fn dotCompletions(
     ip: *InternPool,
     ty: InternPool.Index,
     val: InternPool.Index,
-    node: ?Ast.Node.Index
+    node: ?Ast.Node.Index,
 ) error{OutOfMemory}!void {
     _ = node;
 
@@ -140,7 +140,8 @@ pub fn dotCompletions(
         .error_union_type,
         .function_type,
         .vector_type,
-        .anyframe_type => {},
+        .anyframe_type,
+        => {},
 
         .int_u64_value,
         .int_i64_value,