Add type_name property to reflection types..

Author: dnwpark

gel/_internal/_edgeql/_schema.py

@@ -5,17 +5,13 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, final
+from typing import final
 
 import re
 import uuid
 
 from gel._internal._polyfills._strenum import StrEnum
-from gel._internal._schemapath import SchemaPath, TypeName
-
-
-if TYPE_CHECKING:
-    from collections.abc import Iterable
+from gel._internal._schemapath import ParametricTypeName, SchemaPath, TypeName
 
 
 @final
@@ -75,44 +71,54 @@ def _get_type_id(name: str, cls: str) -> uuid.UUID:
 
 
 def get_array_type_id_and_name(
-    element: str,
-) -> tuple[uuid.UUID, TypeName]:
-    type_id = _get_type_id(f"array<{_mangle_name(element)}>", "Array")
-    type_name = f"array<{element}>"
-    return type_id, SchemaPath(type_name)
+    element: TypeName,
+) -> tuple[uuid.UUID, ParametricTypeName]:
+    type_id = _get_type_id(
+        f"array<{_mangle_name(element.as_schema_name())}>", "Array"
+    )
+    type_name = ParametricTypeName(SchemaPath("std", "array"), [element])
+    return type_id, type_name
 
 
 def get_range_type_id_and_name(
-    element: str,
+    element: TypeName,
 ) -> tuple[uuid.UUID, TypeName]:
-    type_id = _get_type_id(f"range<{_mangle_name(element)}>", "Range")
-    type_name = f"range<{element}>"
-    return type_id, SchemaPath(type_name)
+    type_id = _get_type_id(
+        f"range<{_mangle_name(element.as_schema_name())}>", "Range"
+    )
+    type_name = ParametricTypeName(
+        SchemaPath("std", "range"),
+        [element],
+    )
+    return type_id, type_name
 
 
 def get_multirange_type_id_and_name(
-    element: str,
+    element: TypeName,
 ) -> tuple[uuid.UUID, TypeName]:
     type_id = _get_type_id(
-        f"multirange<{_mangle_name(element)}>", "MultiRange"
+        f"multirange<{_mangle_name(element.as_schema_name())}>", "MultiRange"
     )
-    type_name = f"multirange<{element}>"
-    return type_id, SchemaPath(type_name)
+    type_name = ParametricTypeName(
+        SchemaPath("std", "range"),
+        [element],
+    )
+    return type_id, type_name
 
 
 def get_tuple_type_id_and_name(
-    elements: Iterable[str],
-) -> tuple[uuid.UUID, TypeName]:
-    body = ", ".join(elements)
+    elements: list[TypeName],
+) -> tuple[uuid.UUID, ParametricTypeName]:
+    body = ", ".join(element.as_schema_name() for element in elements)
     type_id = _get_type_id(f"tuple<{_mangle_name(body)}>", "Tuple")
-    type_name = f"tuple<{body}>"
-    return type_id, SchemaPath(type_name)
+    type_name = ParametricTypeName(SchemaPath("std", "tuple"), elements)
+    return type_id, type_name
 
 
 def get_named_tuple_type_id_and_name(
-    elements: dict[str, str],
+    elements: dict[str, TypeName],
 ) -> tuple[uuid.UUID, TypeName]:
-    body = ", ".join(f"{n}:{t}" for n, t in elements.items())
+    body = ", ".join(f"{n}:{t.as_schema_name()}" for n, t in elements.items())
     type_id = _get_type_id(f"tuple<{_mangle_name(body)}>", "Tuple")
     type_name = f"tuple<{body}>"
     return type_id, SchemaPath(type_name)

gel/_internal/_qbmodel/_abstract/_primitive.py

@@ -232,7 +232,7 @@ def __set__(
     @classmethod
     def __gel_reflection__(cls) -> type[GelPrimitiveType.__gel_reflection__]:  # pyright: ignore [reportIncompatibleVariableOverride]
         tid, tname = _edgeql.get_array_type_id_and_name(
-            str(cls.__element_type__.__gel_reflection__.name)
+            cls.__element_type__.__gel_reflection__.name
         )
 
         class __gel_reflection__(GelPrimitiveType.__gel_reflection__):  # noqa: N801
@@ -320,7 +320,7 @@ def __set__(
     @classmethod
     def __gel_reflection__(cls) -> type[GelPrimitiveType.__gel_reflection__]:  # pyright: ignore [reportIncompatibleVariableOverride]
         tid, tname = _edgeql.get_tuple_type_id_and_name(
-            str(el.__gel_reflection__.name) for el in cls.__element_types__
+            [el.__gel_reflection__.name for el in cls.__element_types__]
         )
 
         class __gel_reflection__(GelPrimitiveType.__gel_reflection__):  # noqa: N801
@@ -362,7 +362,7 @@ def __set__(
     @classmethod
     def __gel_reflection__(cls) -> type[GelPrimitiveType.__gel_reflection__]:  # pyright: ignore [reportIncompatibleVariableOverride]
         tid, tname = _edgeql.get_range_type_id_and_name(
-            str(cls.__element_type__.__gel_reflection__.name)
+            cls.__element_type__.__gel_reflection__.name
         )
 
         class __gel_reflection__(GelPrimitiveType.__gel_reflection__):  # noqa: N801

gel/_internal/_reflection/_types.py

@@ -23,7 +23,7 @@
 
 from gel._internal import _dataclass_extras
 from gel._internal import _edgeql
-from gel._internal._schemapath import SchemaPath
+from gel._internal._schemapath import ParametricTypeName, TypeName
 
 from . import _query
 from ._base import struct, sobject, SchemaObject
@@ -69,7 +69,7 @@ def __str__(self) -> str:
 
     @functools.cached_property
     def edgeql(self) -> str:
-        return self.schemapath.as_quoted_schema_name()
+        return self.type_name.as_quoted_schema_name()
 
     @functools.cached_property
     def generic(self) -> bool:
@@ -80,6 +80,10 @@ def generic(self) -> bool:
             and sp.name.startswith("any")
         )
 
+    @functools.cached_property
+    def type_name(self) -> TypeName:
+        return self.schemapath
+
     def assignable_from(
         self,
         other: Type,
@@ -182,10 +186,6 @@ class InheritingType(Type):
     bases: tuple[TypeRef, ...]
     ancestors: tuple[TypeRef, ...]
 
-    @functools.cached_property
-    def edgeql(self) -> str:
-        return self.schemapath.as_quoted_schema_name()
-
     def _assignable_from(
         self,
         other: Type,
@@ -330,11 +330,7 @@ def __post_init__(self) -> None:
 
     @functools.cached_property
     def edgeql(self) -> str:
-        return str(self.schemapath)
-
-    @functools.cached_property
-    def schemapath(self) -> SchemaPath:
-        return SchemaPath.from_segments(self.name)
+        return str(self.type_name)
 
 
 @struct
@@ -361,6 +357,15 @@ def get_element_type(self, schema: Schema) -> Type:
         else:
             return schema[self._element_type_id]
 
+    @functools.cached_property
+    def type_name(self) -> TypeName:
+        if self.element_type is None:
+            return self.schemapath
+        else:
+            return ParametricTypeName(
+                self.schemapath, [self.element_type.type_name]
+            )
+
     @functools.cached_property
     def _element_type_id(self) -> str:
         raise NotImplementedError("_element_type_id")
@@ -457,6 +462,19 @@ def get_element_types(self, schema: Schema) -> tuple[Type, ...]:
         else:
             return tuple(schema[el_tid] for el_tid in self._element_type_ids)
 
+    @functools.cached_property
+    def type_name(self) -> TypeName:
+        if self.element_types is None:
+            return self.schemapath
+        else:
+            return ParametricTypeName(
+                self.schemapath,
+                [
+                    element_type.type_name
+                    for element_type in self.element_types
+                ],
+            )
+
     @functools.cached_property
     def _element_type_ids(self) -> list[str]:
         raise NotImplementedError("_element_type_ids")
@@ -573,8 +591,8 @@ def _element_type_id(self) -> str:
         return self.array_element_id
 
     def get_id_and_name(self, element_type: Type) -> tuple[str, str]:
-        id_, name = _edgeql.get_array_type_id_and_name(element_type.name)
-        return str(id_), name.as_schema_name()
+        id_, _ = _edgeql.get_array_type_id_and_name(element_type.type_name)
+        return str(id_), "std::array"
 
 
 @struct
@@ -599,8 +617,8 @@ def _element_type_id(self) -> str:
         return self.range_element_id
 
     def get_id_and_name(self, element_type: Type) -> tuple[str, str]:
-        id_, name = _edgeql.get_range_type_id_and_name(element_type.name)
-        return str(id_), name.as_schema_name()
+        id_, _ = _edgeql.get_range_type_id_and_name(element_type.type_name)
+        return str(id_), "std::range"
 
 
 @struct
@@ -625,8 +643,10 @@ def _element_type_id(self) -> str:
         return self.multirange_element_id
 
     def get_id_and_name(self, element_type: Type) -> tuple[str, str]:
-        id_, name = _edgeql.get_multirange_type_id_and_name(element_type.name)
-        return str(id_), name.as_schema_name()
+        id_, _ = _edgeql.get_multirange_type_id_and_name(
+            element_type.type_name
+        )
+        return str(id_), "std::multirange"
 
 
 @struct
@@ -662,10 +682,10 @@ def kind(self) -> Literal[TypeKind.Tuple]:
     def get_id_and_name(
         self, element_types: tuple[Type, ...]
     ) -> tuple[str, str]:
-        id_, name = _edgeql.get_tuple_type_id_and_name(
-            el.name for el in element_types
+        id_, _ = _edgeql.get_tuple_type_id_and_name(
+            [el.type_name for el in element_types]
         )
-        return str(id_), name.as_schema_name()
+        return str(id_), "std::tuple"
 
 
 @struct
@@ -686,15 +706,15 @@ def kind(self) -> Literal[TypeKind.NamedTuple]:
     def get_id_and_name(
         self, element_types: tuple[Type, ...]
     ) -> tuple[str, str]:
-        id_, name = _edgeql.get_named_tuple_type_id_and_name(
+        id_, _ = _edgeql.get_named_tuple_type_id_and_name(
             {
-                el.name: el_type.name
+                el.name: el_type.type_name
                 for el, el_type in zip(
                     self.tuple_elements, element_types, strict=True
                 )
             }
         )
-        return str(id_), name.as_schema_name()
+        return str(id_), "std::tuple"
 
 
 def compare_type_generality(a: Type, b: Type, *, schema: Schema) -> int: