Add cast function. (#944)

Allows users to cast between types:
```py
assert client.get(std.str.cast(std.int64(1))) == "1"
assert client.get(std.array[std.str].cast(
    std.array[std.int64](
        [std.int64(1), std.int64(2), std.int64(3)]
    )
) == ["1", "2", "3"]
```

Supports scalars, enums, array, tuple, range. Multiranges not supported, not sure we can even construct them in the qb right now.

Author: dnwpark

gel/_internal/_codegen/_models/_pydantic.py

@@ -839,6 +839,14 @@ def _indirection_key(path: Indirection) -> tuple[str, ...]:
         SchemaPath("std", "multirange"),
     }
 )
+COLLECTION_TYPES = frozenset(
+    {
+        SchemaPath("std", "array"),
+        SchemaPath("std", "tuple"),
+        SchemaPath("std", "range"),
+        SchemaPath("std", "multirange"),
+    }
+)
 
 PSEUDO_TYPES = frozenset(("anytuple", "anyobject", "anytype"))
 
@@ -2352,37 +2360,39 @@ def write_generic_types(
             t_anypt = self.declare_typevar("_T_anypoint", bound=anypoint)
             self.write(f'_Tt = {typevartup}("_Tt")')
 
+            # Order the bases with more specific types first so that
+            # __gel_reflection__ is resolved correctly.
             generics = {
                 SchemaPath("std", "anytype"): [
                     geltype,
                 ],
                 SchemaPath("std", "anyobject"): [
-                    "anytype",
                     gelmodel,
+                    "anytype",
                 ],
                 SchemaPath("std", "anytuple"): [
-                    "anytype",
                     anytuple,
+                    "anytype",
                 ],
                 SchemaPath("std", "anynamedtuple"): [
-                    "anytuple",
                     anynamedtuple,
+                    "anytuple",
                 ],
                 SchemaPath("std", "tuple"): [
-                    "anytuple",
                     f"{tup}[{unpack}[_Tt]]",
+                    "anytuple",
                 ],
                 SchemaPath("std", "array"): [
-                    "anytype",
                     f"{arr}[{t_anytype}]",
+                    "anytype",
                 ],
                 SchemaPath("std", "range"): [
-                    "anytype",
                     f"{rang}[{t_anypt}]",
+                    "anytype",
                 ],
                 SchemaPath("std", "multirange"): [
-                    "anytype",
                     f"{mrang}[{t_anypt}]",
+                    "anytype",
                 ],
             }
 
@@ -2515,7 +2525,17 @@ def write_generic_types(
                     suggested_module_alias=rel_import.module_alias,
                 )
                 type_ident = ident(gt.name)
-                self.write(f"{type_ident} = {imported_name}")
+
+                if gt in COLLECTION_TYPES:
+                    # Import collection classes directly so mypy sees them as
+                    # generic classes, not type aliases
+                    self.write(
+                        f"from {rel_import.module} "
+                        f"import {type_ident} as {type_ident}"
+                    )
+                else:
+                    self.write(f"{type_ident} = {imported_name}")
+
                 self.export(type_ident)
 
     def _write_enum_scalar_type(
@@ -2533,9 +2553,43 @@ def _write_enum_scalar_type(
             self.write_description(stype)
             for value in stype.enum_values:
                 self.write(f"{ident(value)} = {value!r}")
+
+            self.write()
             self.write_type_reflection(stype)
+
+            self.write()
+            self._write_enum_scalar_cast(stype)
+
         self.write_section_break()
 
+    def _write_enum_scalar_cast(
+        self,
+        stype: reflection.ScalarType,
+    ) -> None:
+        expr_compat = self.import_name(BASE_IMPL, "ExprCompatible")
+
+        type_ = self.import_name("builtins", "type")
+        self_ = self.import_name("typing_extensions", "Self")
+        type_self = f"{type_}[{self_}]"
+
+        aexpr = self.import_name(BASE_IMPL, "AnnotatedExpr")
+        cast_op = self.import_name(BASE_IMPL, "CastOp")
+
+        with self._classmethod_def(
+            "cast",
+            [f"expr: {expr_compat}"],
+            type_self,
+        ):
+            self.write(f"return {aexpr}(  # type: ignore [return-value]")
+            with self.indented():
+                self.write("cls,")
+                self.write(f"{cast_op}(")
+                with self.indented():
+                    self.write("expr=expr,")
+                    self.write("type_=cls.__gel_reflection__.type_name,")
+                self.write(")")
+            self.write(")")
+
     def _write_scalar_type(
         self,
         stype: reflection.ScalarType,
@@ -2624,6 +2678,8 @@ def _write_regular_scalar_type(
 
             self.export("anyenum")
 
+        is_generic = type_name in GENERIC_TYPES
+
         if not runtime_parents:
             typecheck_parents = [self.get_type(self._types_by_name["anytype"])]
             runtime_parents = typecheck_parents
@@ -2725,6 +2781,9 @@ def _write_regular_scalar_type(
                     ):
                         self.write("...")
 
+                if not is_generic:
+                    self._write_regular_scalar_cast(stype, signature_only=True)
+
         self.write()
 
         with self.not_type_checking():
@@ -2739,8 +2798,55 @@ def _write_regular_scalar_type(
                     self.write()
                 self.write_type_reflection(stype)
 
+                if not is_generic:
+                    self.write()
+                    self._write_regular_scalar_cast(
+                        stype, signature_only=False
+                    )
+
         self.write_section_break()
 
+    def _write_regular_scalar_cast(
+        self,
+        stype: reflection.ScalarType,
+        *,
+        signature_only: bool,
+    ) -> None:
+        expr_compat = self.import_name(BASE_IMPL, "ExprCompatible")
+
+        type_ = self.import_name("builtins", "type")
+        self_ = self.import_name("typing_extensions", "Self")
+        type_self = f"{type_}[{self_}]"
+
+        if signature_only:
+            self.write()
+            with self._classmethod_def(
+                "cast",
+                [f"expr: {expr_compat}"],
+                type_self,
+            ):
+                self.write("...")
+
+        else:
+            aexpr = self.import_name(BASE_IMPL, "AnnotatedExpr")
+            cast_op = self.import_name(BASE_IMPL, "CastOp")
+
+            self.write()
+            with self._classmethod_def(
+                "cast",
+                [f"expr: {expr_compat}"],
+                type_self,
+            ):
+                self.write(f"return {aexpr}(  # type: ignore [return-value]")
+                with self.indented():
+                    self.write("cls,")
+                    self.write(f"{cast_op}(")
+                    with self.indented():
+                        self.write("expr=expr,")
+                        self.write("type_=cls.__gel_reflection__.type_name,")
+                    self.write(")")
+                self.write(")")
+
     def render_callable_return_type(
         self,
         tp: reflection.Type,

gel/_internal/_qbmodel/_abstract/_primitive.py

@@ -269,6 +269,22 @@ def _reconstruct_from_pickle(
     def __gel_get_py_type__(cls) -> type:
         return list
 
+    def __edgeql_literal__(self) -> _qb.Literal:
+        return _qb.Literal(
+            type_=type(self).__gel_reflection__.type_name,
+            val=self,
+        )
+
+    @classmethod
+    def cast(cls, expr: _qb.ExprCompatible) -> type[Array[_T]]:
+        return _qb.AnnotatedExpr(  # type: ignore [return-value]
+            cls,
+            _qb.CastOp(
+                expr=expr,
+                type_=cls.__gel_reflection__.type_name,
+            ),
+        )
+
 
 _Ts = TypeVarTuple("_Ts")
 
@@ -335,6 +351,27 @@ class __gel_reflection__(GelPrimitiveType.__gel_reflection__):  # noqa: N801
     def __gel_get_py_type__(cls) -> type:
         return tuple
 
+    def __edgeql_literal__(self) -> _qb.Literal:
+        return _qb.Literal(
+            type_=type(self).__gel_reflection__.type_name,
+            val=self,
+        )
+
+    @classmethod
+    def cast(cls, expr: _qb.ExprCompatible) -> Self:
+        return _qb.AnnotatedExpr(  # type: ignore [return-value]
+            cls,
+            _qb.CastOp(
+                expr=expr,
+                type_=cls.__gel_reflection__.type_name,
+            ),
+        )
+
+    if TYPE_CHECKING:
+
+        def __new__(cls, args: tuple[Any, ...]) -> Self: ...
+        def __init__(self, args: tuple[Unpack[_Ts]]): ...
+
 
 if TYPE_CHECKING:
 
@@ -374,6 +411,16 @@ class __gel_reflection__(GelPrimitiveType.__gel_reflection__):  # noqa: N801
 
         return __gel_reflection__
 
+    @classmethod
+    def cast(cls, expr: _qb.ExprCompatible) -> type[Range[_T]]:
+        return _qb.AnnotatedExpr(  # type: ignore [return-value]
+            cls,
+            _qb.CastOp(
+                expr=expr,
+                type_=cls.__gel_reflection__.type_name,
+            ),
+        )
+
 
 if TYPE_CHECKING:
 
@@ -459,6 +506,9 @@ def get_py_type_from_gel_type(tp: type[GelType]) -> Any:
         case t if issubclass(t, PyTypeScalar):
             return t.__gel_py_type__
 
+        case t if issubclass(t, AnyEnum):
+            return t
+
         case t:
             raise NotImplementedError(
                 f"get_py_type({t.__name__}) is not implemented"

gel/models/pydantic.py

@@ -22,6 +22,7 @@
     OPERAND_IS_ALIAS,
     AnnotatedExpr,
     BaseAlias,
+    CastOp,
     EmptyDirection,
     Direction,
     GelLinkMetadata,
@@ -116,6 +117,7 @@
     "ArrayMeta",
     "BaseAlias",
     "Cardinality",
+    "CastOp",
     "ComputedLink",
     "ComputedLinkWithProps",
     "ComputedMultiLink",