Fix passing type intersections to overloaded functions.

Author: dnwpark

gel/_internal/_typing_dispatch.py

@@ -38,6 +38,7 @@
 from gel._internal import _typing_inspect
 from gel._internal import _typing_parametric
 from gel._internal._utils import type_repr
+from gel._internal._qbmodel._abstract._methods import BaseGelModelIntersection
 
 _P = ParamSpec("_P")
 _R_co = TypeVar("_R_co", covariant=True)
@@ -66,6 +67,10 @@ def _issubclass(lhs: Any, tp: Any, fn: Any) -> bool:
     # subtypes of the variable bounds.
     # This lets us handle cases like:
     # std.array[Object] <: std.array[_T_anytype].
+
+    if issubclass(lhs, BaseGelModelIntersection):
+        return any(_issubclass(c, tp, fn) for c in (lhs.lhs, lhs.rhs))
+
     if _typing_inspect.is_generic_alias(tp):
         origin = typing.get_origin(tp)
         args = typing.get_args(tp)

tests/test_qb.py

@@ -1695,9 +1695,7 @@ def test_qb_is_type_basic_07(self):
         # Link TypeIntersection
         from models.orm_qb import default
 
-        result = self.client.query(
-            default.Link_Inh_A.l.is_(default.Inh_B)
-        )
+        result = self.client.query(default.Link_Inh_A.l.is_(default.Inh_B))
 
         self._assertObjectsWithFields(
             result,
@@ -1900,9 +1898,9 @@ def test_qb_is_type_for_01(self):
         from models.orm_qb import default, std
 
         result = self.client.query(
-            std.for_(
-                default.Inh_A.is_(default.Inh_B), lambda x: x
-            ).select(a=True)
+            std.for_(default.Inh_A.is_(default.Inh_B), lambda x: x).select(
+                a=True
+            )
         )
 
         self._assertObjectsWithFields(
@@ -2014,6 +2012,78 @@ def test_qb_is_type_for_03(self):
             excluded_fields={'b', 'c', 'ab', 'ac', 'bc', 'abc', 'ab_ac'},
         )
 
+    def test_qb_is_type_as_function_arg_01(self):
+        # Test that type exprs produced by is_ can be passed as function args
+        from models.orm_qb import default, std
+
+        result = self.client.query(
+            std.distinct(default.Inh_A.is_(default.Inh_B)).select('*')
+        )
+
+        self._assertObjectsWithFields(
+            result,
+            "a",
+            [
+                (
+                    default.Inh_AB,
+                    {
+                        "a": 4,
+                        "b": 5,
+                    },
+                ),
+                (
+                    default.Inh_ABC,
+                    {
+                        "a": 13,
+                        "b": 14,
+                    },
+                ),
+                (
+                    default.Inh_AB_AC,
+                    {
+                        "a": 17,
+                        "b": 18,
+                    },
+                ),
+            ],
+            excluded_fields={'c', 'ab', 'ac', 'bc', 'abc', 'ab_ac'},
+        )
+
+    def test_qb_is_type_as_function_arg_02(self):
+        # Test that complex type exprs produced by is_ can be passed as
+        # function args
+        from models.orm_qb import default, std
+
+        result = self.client.query(
+            std.distinct(
+                default.Inh_A.is_(default.Inh_B).is_(default.Inh_C)
+            ).select('*')
+        )
+
+        self._assertObjectsWithFields(
+            result,
+            "a",
+            [
+                (
+                    default.Inh_ABC,
+                    {
+                        "a": 13,
+                        "b": 14,
+                        "c": 15,
+                    },
+                ),
+                (
+                    default.Inh_AB_AC,
+                    {
+                        "a": 17,
+                        "b": 18,
+                        "c": 19,
+                    },
+                ),
+            ],
+            excluded_fields={'ab', 'ac', 'bc', 'abc', 'ab_ac'},
+        )
+
 
 class TestQueryBuilderModify(tb.ModelTestCase):
     """This test suite is for data manipulation using QB."""