Add hack for bool overload.

Author: dnwpark

gel/_internal/_codegen/_models/_pydantic.py

@@ -3721,16 +3721,67 @@ def _write_potentially_overlapping_overloads(
             # SEE ABOVE: This is what we actually want.
             # key=lambda o: (generality_key(o), o.edgeql_signature),  # noqa: ERA001, E501
         )
+        base_generic_overload: dict[_Callable_T, _Callable_T] = {}
 
         for overload in overloads:
             overload_signatures[overload] = {}
+
+            if overload.schemapath == SchemaPath('std', 'IF'):
+                # HACK: Pretend the base overload of std::IF is generic on
+                # anyobject.
+                #
+                # The base overload of std::IF is
+                #   (anytype, std::bool, anytype) -> anytype
+                #
+                # However, this causes an overlap with overloading for bool
+                # arguments since
+                #   (anytype, builtin.bool, anytype) -> anytype
+                # overlaps with
+                #   (std::bool, builtin.bool, std::bool) -> std::bool
+                #
+                # We resolve this by generating the specializations for anytype
+                # but using anyobject as the base generic type.
+
+                def anytype_to_anyobject(
+                    refl_type: reflection.Type,
+                    default: reflection.Type | reflection.TypeRef,
+                ) -> reflection.Type | reflection.TypeRef:
+                    if isinstance(refl_type, reflection.PseudoType):
+                        return self._types_by_name["anyobject"]
+                    return default
+
+                base_generic_overload[overload] = dataclasses.replace(
+                    overload,
+                    params=[
+                        dataclasses.replace(
+                            param,
+                            type=anytype_to_anyobject(
+                                param.get_type(self._types), param.type
+                            ),
+                        )
+                        for param in overload.params
+                    ],
+                    return_type=anytype_to_anyobject(
+                        overload.get_return_type(self._types),
+                        overload.return_type,
+                    ),
+                )
+
             for param in param_getter(overload):
                 param_overload_map[param.key].add(overload)
                 param_type = param.get_type(self._types)
                 # Unwrap the variadic type (it is reflected as an array of T)
                 if param.kind is reflection.CallableParamKind.Variadic:
                     if reflection.is_array_type(param_type):
                         param_type = param_type.get_element_type(self._types)
+
+                if (
+                    overload.schemapath == SchemaPath('std', 'IF')
+                    and param_type.is_pseudo
+                ):
+                    # Also generate the base signature using anyobject
+                    param_type = self._types_by_name["anyobject"]
+
                 # Start with the base parameter type
                 overload_signatures[overload][param.key] = [param_type]
 
@@ -3842,7 +3893,10 @@ def specialization_sort_key(t: reflection.Type) -> int:
             for overload in overloads:
                 if overload_specs := overloads_specializations.get(overload):
                     expanded_overloads.extend(overload_specs)
-                expanded_overloads.append(overload)
+                if overload in base_generic_overload:
+                    expanded_overloads.append(base_generic_overload[overload])
+                else:
+                    expanded_overloads.append(overload)
             overloads = expanded_overloads
 
         overload_order = {overload: i for i, overload in enumerate(overloads)}

gel/_internal/_reflection/__init__.py

@@ -68,6 +68,7 @@
     ScalarType,
     TupleType,
     Type,
+    TypeRef,
     compare_type_generality,
     fetch_types,
     is_abstract_type,
@@ -126,6 +127,7 @@
     "Type",
     "TypeKind",
     "TypeModifier",
+    "TypeRef",
     "compare_callable_generality",
     "compare_type_generality",
     "fetch_branch_state",