Replace arena parameter with analyser in getAllTypesWithHandles

Author: FnControlOption

src/analysis.zig

@@ -3683,18 +3683,19 @@ pub const Type = struct {
 
     /// Resolves possible types of a type (single for all except either)
     /// Drops duplicates
-    pub fn getAllTypesWithHandles(ty: Type, arena: std.mem.Allocator) error{OutOfMemory}![]const Type {
+    pub fn getAllTypesWithHandles(ty: Type, analyser: *Analyser) error{OutOfMemory}![]const Type {
         var all_types: ArraySet = .empty;
-        try ty.getAllTypesWithHandlesArraySet(arena, &all_types);
+        try ty.getAllTypesWithHandlesArraySet(analyser, &all_types);
         return all_types.keys();
     }
 
-    pub fn getAllTypesWithHandlesArraySet(ty: Type, arena: std.mem.Allocator, all_types: *ArraySet) !void {
+    pub fn getAllTypesWithHandlesArraySet(ty: Type, analyser: *Analyser, all_types: *ArraySet) !void {
+        const arena = analyser.arena;
         switch (ty.data) {
             .either => |entries| {
                 for (entries) |entry| {
                     const entry_ty: Type = .{ .data = entry.type_data, .is_type_val = ty.is_type_val };
-                    try entry_ty.getAllTypesWithHandlesArraySet(arena, all_types);
+                    try entry_ty.getAllTypesWithHandlesArraySet(analyser, all_types);
                 }
             },
             else => try all_types.put(arena, ty, {}),
@@ -6103,7 +6104,7 @@ pub fn getSymbolFieldAccesses(
     if (try analyser.getFieldAccessType(handle, source_index, held_loc)) |ty| {
         const container_handle = try analyser.resolveDerefType(ty) orelse ty;
 
-        const container_handle_nodes = try container_handle.getAllTypesWithHandles(arena);
+        const container_handle_nodes = try container_handle.getAllTypesWithHandles(analyser);
 
         for (container_handle_nodes) |t| {
             try decls_with_handles.append(arena, (try t.lookupSymbol(analyser, name)) orelse continue);

src/features/completions.zig

@@ -1513,7 +1513,7 @@ fn collectContainerNodes(
         .identifier_token_index => |token| token,
         .expr_node_index => |node| {
             if (try builder.analyser.resolveTypeOfNode(.of(node, handle))) |ty| {
-                try ty.getAllTypesWithHandlesArraySet(builder.arena, &types_with_handles);
+                try ty.getAllTypesWithHandlesArraySet(builder.analyser, &types_with_handles);
             }
             return types_with_handles.keys();
         },
@@ -1533,7 +1533,7 @@ fn collectContainerNodes(
                 const var_decl = handle.tree.fullVarDecl(nodes[1]).?;
                 if (nodes[0].toOptional() == var_decl.ast.type_node) {
                     if (try builder.analyser.resolveTypeOfNode(.of(nodes[0], handle))) |ty| {
-                        try ty.getAllTypesWithHandlesArraySet(builder.arena, &types_with_handles);
+                        try ty.getAllTypesWithHandlesArraySet(builder.analyser, &types_with_handles);
                         return types_with_handles.keys();
                     }
                 }
@@ -1579,7 +1579,7 @@ fn collectBuiltinContainerNodes(
         dot_context.fn_arg_index,
         handle.tree.source[loc.start..loc.end],
     )) |ty| {
-        try ty.getAllTypesWithHandlesArraySet(builder.arena, types_with_handles);
+        try ty.getAllTypesWithHandlesArraySet(builder.analyser, types_with_handles);
     }
 }
 
@@ -1591,13 +1591,12 @@ fn collectVarAccessContainerNodes(
     types_with_handles: *Analyser.Type.ArraySet,
 ) error{OutOfMemory}!void {
     const analyser = builder.analyser;
-    const arena = builder.arena;
 
     const symbol_decl = try analyser.lookupSymbolGlobal(handle, handle.tree.source[loc.start..loc.end], loc.end) orelse return;
     const result = try symbol_decl.resolveType(analyser) orelse return;
     const type_expr = try analyser.resolveDerefType(result) orelse result;
     if (!type_expr.isFunc()) {
-        try type_expr.getAllTypesWithHandlesArraySet(arena, types_with_handles);
+        try type_expr.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
         return;
     }
 
@@ -1606,13 +1605,13 @@ fn collectVarAccessContainerNodes(
     if (dot_context.likely == .enum_comparison or dot_context.need_ret_type) { // => we need f()'s return type
         var node_type = try analyser.resolveReturnType(type_expr) orelse return;
         if (try analyser.resolveUnwrapErrorUnionType(node_type, .payload)) |unwrapped| node_type = unwrapped;
-        try node_type.getAllTypesWithHandlesArraySet(arena, types_with_handles);
+        try node_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
         return;
     }
     const param_index = dot_context.fn_arg_index;
     if (param_index >= info.parameters.len) return;
     const param_type = info.parameters[param_index].type;
-    try param_type.getAllTypesWithHandlesArraySet(arena, types_with_handles);
+    try param_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
 }
 
 fn collectFieldAccessContainerNodes(
@@ -1634,12 +1633,12 @@ fn collectFieldAccessContainerNodes(
         const container = try analyser.resolveDerefType(result) orelse result;
         if (try analyser.resolveUnwrapErrorUnionType(container, .payload)) |unwrapped| {
             if (unwrapped.isEnumType() or unwrapped.isUnionType()) {
-                try unwrapped.getAllTypesWithHandlesArraySet(arena, types_with_handles);
+                try unwrapped.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
                 return;
             }
         }
         // if (dot_context.likely == .enum_literal and !(container.isEnumType() or container.isUnionType())) return;
-        try container.getAllTypesWithHandlesArraySet(arena, types_with_handles);
+        try container.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
         return;
     };
     const name = offsets.locToSlice(handle.tree.source, name_loc);
@@ -1651,7 +1650,7 @@ fn collectFieldAccessContainerNodes(
             if (try analyser.resolveOptionalUnwrap(node_type)) |unwrapped| node_type = unwrapped;
         }
         if (!node_type.isFunc()) {
-            try node_type.getAllTypesWithHandlesArraySet(arena, types_with_handles);
+            try node_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
             continue;
         }
 
@@ -1660,7 +1659,7 @@ fn collectFieldAccessContainerNodes(
         if (dot_context.need_ret_type) { // => we need f()'s return type
             node_type = try analyser.resolveReturnType(node_type) orelse continue;
             if (try analyser.resolveUnwrapErrorUnionType(node_type, .payload)) |unwrapped| node_type = unwrapped;
-            try node_type.getAllTypesWithHandlesArraySet(arena, types_with_handles);
+            try node_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
             continue;
         }
         // don't have the luxury of referencing an `Ast.full.Call`
@@ -1683,7 +1682,7 @@ fn collectFieldAccessContainerNodes(
         const param_index = dot_context.fn_arg_index + additional_index;
         if (param_index >= params.len) continue;
         const param_type = params[param_index].type;
-        try param_type.getAllTypesWithHandlesArraySet(arena, types_with_handles);
+        try param_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
     }
 }
 
@@ -1695,7 +1694,6 @@ fn collectEnumLiteralContainerNodes(
     types_with_handles: *Analyser.Type.ArraySet,
 ) error{OutOfMemory}!void {
     const analyser = builder.analyser;
-    const arena = builder.arena;
     const alleged_field_name = offsets.locToSlice(handle.tree.source, offsets.identifierIndexToLoc(handle.tree.source, loc.start + 1, .name));
     const dot_index = offsets.sourceIndexToTokenIndex(handle.tree, loc.start).pickPreferred(&.{.period}, &handle.tree) orelse return;
     const el_dot_context = getSwitchOrStructInitContext(handle.tree, dot_index, nodes) orelse return;
@@ -1706,7 +1704,7 @@ fn collectEnumLiteralContainerNodes(
         var member_type = try member_decl.resolveType(analyser) orelse continue;
         // Unwrap `x{ .fld_w_opt_type =`
         if (try analyser.resolveOptionalUnwrap(member_type)) |unwrapped| member_type = unwrapped;
-        try member_type.getAllTypesWithHandlesArraySet(arena, types_with_handles);
+        try member_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
     }
 }
 
@@ -1730,5 +1728,5 @@ fn collectKeywordFnContainerNodes(
         }
     };
     const ty = try builder.analyser.instanceStdBuiltinType(builtin_type_name) orelse return;
-    try ty.getAllTypesWithHandlesArraySet(builder.arena, types_with_handles);
+    try ty.getAllTypesWithHandlesArraySet(builder.analyser, types_with_handles);
 }