Limit number of combinations when expanding conditional type

Set the maximum to 200 since VS Code's hover popup seems to be
limited to ~220 lines anyways.

Author: FnControlOption

src/analysis.zig

@@ -40,6 +40,7 @@ collect_callsite_references: bool,
 resolve_number_literal_values: bool,
 /// handle of the doc where the request originated
 root_handle: ?*DocumentStore.Handle,
+max_conditional_combos: usize = 200,
 
 const NodeSet = std.HashMapUnmanaged(NodeWithUri, void, NodeWithUri.Context, std.hash_map.default_max_load_percentage);
 
@@ -3689,7 +3690,7 @@ pub const Type = struct {
     /// Drops duplicates
     pub fn getAllTypesWithHandles(ty: Type, analyser: *Analyser) error{OutOfMemory}![]const Type {
         var all_types: ArraySet = .empty;
-        try ty.getAllTypesWithHandlesArraySet(analyser, &all_types);
+        _ = try ty.getAllTypesWithHandlesArraySet(analyser, &all_types);
         return all_types.keys();
     }
 
@@ -3732,12 +3733,15 @@ pub const Type = struct {
         };
     }
 
-    // is infinite recursion possible here?
-    pub fn getAllTypesWithHandlesArraySet(ty: Type, analyser: *Analyser, all_types: *ArraySet) !void {
+    /// Returns true if we have reached the limit for analyzing combinations
+    pub fn getAllTypesWithHandlesArraySet(ty: Type, analyser: *Analyser, all_types: *ArraySet) !bool {
+        if (all_types.count() >= analyser.max_conditional_combos) {
+            return true;
+        }
         const arena = analyser.arena;
         if (!ty.isConditional()) {
             try all_types.put(arena, ty, {});
-            return;
+            return false;
         }
         switch (ty.data) {
             .union_tag,
@@ -3749,24 +3753,34 @@ pub const Type = struct {
             .either => |entries| {
                 for (entries) |entry| {
                     const entry_ty: Type = .{ .data = entry.type_data, .is_type_val = ty.is_type_val };
-                    try entry_ty.getAllTypesWithHandlesArraySet(analyser, all_types);
+                    if (try entry_ty.getAllTypesWithHandlesArraySet(analyser, all_types)) {
+                        return true;
+                    }
                 }
             },
             .anytype_parameter => |info| {
                 if (info.type_from_callsite_references) |t| {
-                    try t.getAllTypesWithHandlesArraySet(analyser, all_types);
+                    if (try t.getAllTypesWithHandlesArraySet(analyser, all_types)) {
+                        return true;
+                    }
                 } else {
                     try all_types.put(arena, ty, {});
                 }
             },
             .optional => |child_ty| {
                 for (try child_ty.getAllTypesWithHandles(analyser)) |t| {
+                    if (all_types.count() >= analyser.max_conditional_combos) {
+                        return true;
+                    }
                     const new_child_ty = try analyser.allocType(t);
                     try all_types.put(arena, .{ .data = .{ .optional = new_child_ty }, .is_type_val = ty.is_type_val }, {});
                 }
             },
             inline .pointer, .array => |info, tag| {
                 for (try info.elem_ty.getAllTypesWithHandles(analyser)) |t| {
+                    if (all_types.count() >= analyser.max_conditional_combos) {
+                        return true;
+                    }
                     var new_info = info;
                     new_info.elem_ty = try analyser.allocType(t);
                     const data = @unionInit(Type.Data, @tagName(tag), new_info);
@@ -3780,6 +3794,9 @@ pub const Type = struct {
                 }
                 var iter: ComboIterator = try .init(arena, &possible_types);
                 while (iter.next()) |combo| {
+                    if (all_types.count() >= analyser.max_conditional_combos) {
+                        return true;
+                    }
                     const new_types = try arena.alloc(Type, types.len);
                     for (new_types, types) |*new, old| new.* = combo.get(old).?;
                     try all_types.put(arena, .{ .data = .{ .tuple = new_types }, .is_type_val = ty.is_type_val }, {});
@@ -3793,6 +3810,9 @@ pub const Type = struct {
                 }
                 var iter: ComboIterator = try .init(arena, &possible_types);
                 while (iter.next()) |combo| {
+                    if (all_types.count() >= analyser.max_conditional_combos) {
+                        return true;
+                    }
                     const new_types = try arena.alloc(Type, types.len);
                     for (new_types, types) |*new, old| new.* = combo.get(old).?;
                     var new_info = info;
@@ -3808,6 +3828,9 @@ pub const Type = struct {
                 }
                 var iter: ComboIterator = try .init(arena, &possible_types);
                 while (iter.next()) |combo| {
+                    if (all_types.count() >= analyser.max_conditional_combos) {
+                        return true;
+                    }
                     var new_info = info;
                     new_info.payload = try analyser.allocType(combo.get(info.payload.*).?);
                     if (info.error_set) |t| {
@@ -3830,6 +3853,9 @@ pub const Type = struct {
                 }
                 var iter: ComboIterator = try .init(arena, &possible_types);
                 while (iter.next()) |combo| {
+                    if (all_types.count() >= analyser.max_conditional_combos) {
+                        return true;
+                    }
                     var new_info = info;
                     new_info.container_type = try analyser.allocType(combo.get(info.container_type.*).?);
                     new_info.parameters = try arena.alloc(Data.Parameter, info.parameters.len);
@@ -3848,6 +3874,7 @@ pub const Type = struct {
                 }
             },
         }
+        return false;
     }
 
     const ComboIterator = struct {

src/features/completions.zig

@@ -1512,7 +1512,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.analyser, &types_with_handles);
+                _ = try ty.getAllTypesWithHandlesArraySet(builder.analyser, &types_with_handles);
             }
             return types_with_handles.keys();
         },
@@ -1532,7 +1532,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.analyser, &types_with_handles);
+                        _ = try ty.getAllTypesWithHandlesArraySet(builder.analyser, &types_with_handles);
                         return types_with_handles.keys();
                     }
                 }
@@ -1578,7 +1578,7 @@ fn collectBuiltinContainerNodes(
         dot_context.fn_arg_index,
         handle.tree.source[loc.start..loc.end],
     )) |ty| {
-        try ty.getAllTypesWithHandlesArraySet(builder.analyser, types_with_handles);
+        _ = try ty.getAllTypesWithHandlesArraySet(builder.analyser, types_with_handles);
     }
 }
 
@@ -1595,7 +1595,7 @@ fn collectVarAccessContainerNodes(
     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(analyser, types_with_handles);
+        _ = try type_expr.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
         return;
     }
 
@@ -1604,13 +1604,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(analyser, 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(analyser, types_with_handles);
+    _ = try param_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
 }
 
 fn collectFieldAccessContainerNodes(
@@ -1632,12 +1632,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(analyser, 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(analyser, types_with_handles);
+        _ = try container.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
         return;
     };
     const name = offsets.locToSlice(handle.tree.source, name_loc);
@@ -1649,7 +1649,7 @@ fn collectFieldAccessContainerNodes(
             if (try analyser.resolveOptionalUnwrap(node_type)) |unwrapped| node_type = unwrapped;
         }
         if (!node_type.isFunc()) {
-            try node_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
+            _ = try node_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
             continue;
         }
 
@@ -1658,7 +1658,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(analyser, types_with_handles);
+            _ = try node_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
             continue;
         }
         // don't have the luxury of referencing an `Ast.full.Call`
@@ -1681,7 +1681,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(analyser, types_with_handles);
+        _ = try param_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
     }
 }
 
@@ -1703,7 +1703,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(analyser, types_with_handles);
+        _ = try member_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
     }
 }
 
@@ -1727,5 +1727,5 @@ fn collectKeywordFnContainerNodes(
         }
     };
     const ty = try builder.analyser.instanceStdBuiltinType(builtin_type_name) orelse return;
-    try ty.getAllTypesWithHandlesArraySet(builder.analyser, types_with_handles);
+    _ = try ty.getAllTypesWithHandlesArraySet(builder.analyser, types_with_handles);
 }

src/features/hover.zig

@@ -101,15 +101,17 @@ fn hoverSymbolRecursive(
 
     var referenced: Analyser.ReferencedType.Set = .empty;
     var resolved_type_strings: std.ArrayListUnmanaged([]const u8) = .empty;
+    var has_more = false;
     if (try decl_handle.resolveType(analyser)) |resolved_type| {
         if (try resolved_type.docComments(arena)) |doc|
             try doc_strings.append(arena, doc);
         const typeof = try resolved_type.typeOf(analyser);
-        const possible_types = try typeof.getAllTypesWithHandles(analyser);
-        for (possible_types) |ty| {
+        var possible_types: Analyser.Type.ArraySet = .empty;
+        has_more = try typeof.getAllTypesWithHandlesArraySet(analyser, &possible_types);
+        for (possible_types.keys()) |ty| {
             try resolved_type_strings.append(arena, try std.fmt.allocPrint(arena, "{}", .{ty.fmtTypeVal(analyser, .{
                 .referenced = &referenced,
-                .truncate_container_decls = possible_types.len > 1,
+                .truncate_container_decls = possible_types.count() > 1,
             })}));
         }
     }
@@ -120,6 +122,7 @@ fn hoverSymbolRecursive(
         doc_strings.items,
         def_str,
         resolved_type_strings.items,
+        has_more,
         referenced_types,
     );
 }
@@ -130,6 +133,7 @@ fn hoverSymbolResolved(
     doc_strings: []const []const u8,
     def_str: []const u8,
     resolved_type_strings: []const []const u8,
+    has_more: bool,
     referenced_types: []const Analyser.ReferencedType,
 ) error{OutOfMemory}![]const u8 {
     var hover_text: std.ArrayListUnmanaged(u8) = .empty;
@@ -140,6 +144,8 @@ fn hoverSymbolResolved(
             try writer.print("\n```zig\n({s})\n```", .{resolved_type_str});
         if (resolved_type_strings.len == 0)
             try writer.writeAll("\n```zig\n(unknown)\n```");
+        if (has_more)
+            try writer.print("\n```txt\n(...)\n```", .{});
         if (referenced_types.len > 0)
             try writer.print("\n\n" ++ "Go to ", .{});
         for (referenced_types, 0..) |ref, index| {
@@ -155,6 +161,8 @@ fn hoverSymbolResolved(
             try writer.print("\n({s})", .{resolved_type_str});
         if (resolved_type_strings.len == 0)
             try writer.writeAll("\n(unknown)");
+        if (has_more)
+            try writer.print("\n(...)", .{});
     }
 
     if (doc_strings.len > 0) {
@@ -288,7 +296,7 @@ fn hoverDefinitionGlobal(
             if (std.mem.eql(u8, name, "_")) return null;
             if (try analyser.resolvePrimitive(name)) |ip_index| {
                 const resolved_type_str = try std.fmt.allocPrint(arena, "{}", .{analyser.ip.typeOf(ip_index).fmt(analyser.ip)});
-                break :blk try hoverSymbolResolved(arena, markup_kind, &.{}, name, &.{resolved_type_str}, &.{});
+                break :blk try hoverSymbolResolved(arena, markup_kind, &.{}, name, &.{resolved_type_str}, false, &.{});
             }
         }
         const decl = (try analyser.lookupSymbolGlobal(handle, name, pos_index)) orelse return null;