Update save to use TypeName from reflection.

Author: dnwpark

gel/_internal/_codegen/_models/_pydantic.py

@@ -1152,7 +1152,7 @@ def write_schema_reflection(
             obj_name = sobj.schemapath.as_python_code(sp_clsname, ptn_clsname)
             self.write(f"name = {obj_name}")
             if isinstance(sobj, reflection.Type):
-                type_name = sobj.type_name.as_python_code(
+                type_name = sobj.get_type_name(self._types).as_python_code(
                     sp_clsname, ptn_clsname
                 )
                 self.write(f"type_name = {type_name}")
@@ -1197,7 +1197,7 @@ def write_object_type_reflection(
             obj_name = objtype.schemapath.as_python_code(
                 sp_clsname, ptn_clsname
             )
-            type_name = objtype.type_name.as_python_code(
+            type_name = objtype.get_type_name(self._types).as_python_code(
                 sp_clsname, ptn_clsname
             )
             self.write(f"name = {obj_name}")
@@ -1319,10 +1319,9 @@ def _reflect_pointer(
         target_type = self._types[ptr.target_id]
         kwargs: dict[str, str] = {
             "name": repr(ptr.name),
-            "type": target_type.schemapath.as_python_code(
+            "type": target_type.get_type_name(self._types).as_python_code(
                 classes["SchemaPath"], classes["ParametricTypeName"]
             ),
-            "typexpr": repr(target_type.type_name.as_quoted_schema_name()),
             "kind": f"{classes['PointerKind']}({str(ptr.kind)!r})",
             "cardinality": f"{classes['Cardinality']}({str(ptr.card)!r})",
             "computed": str(ptr.is_computed),

gel/_internal/_qb/_reflection.py

@@ -16,8 +16,7 @@
 @dataclasses.dataclass(frozen=True, kw_only=True)
 class GelPointerReflection:
     name: str
-    type: SchemaPath
-    typexpr: str
+    type: TypeName
     kind: _edgeql.PointerKind
     cardinality: _edgeql.Cardinality
     computed: bool

gel/_internal/_reflection/_types.py

@@ -7,6 +7,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    ClassVar,
     Literal,
     TypeGuard,
     TypeVar,
@@ -40,10 +41,7 @@
 @struct
 class TypeRef:
     id: str
-    name: str
-
-    def __str__(self) -> str:
-        return self.name
+    name: TypeName
 
 
 @sobject
@@ -64,9 +62,6 @@ class Type(SchemaObject, abc.ABC):
     def kind(self) -> TypeKind:
         return kind_of_type(self)
 
-    def __str__(self) -> str:
-        return self.name
-
     @functools.cached_property
     def generic(self) -> bool:
         sp = self.schemapath
@@ -76,8 +71,7 @@ def generic(self) -> bool:
             and sp.name.startswith("any")
         )
 
-    @functools.cached_property
-    def type_name(self) -> TypeName:
+    def get_type_name(self, schema: Schema) -> TypeName:
         return self.schemapath
 
     def assignable_from(
@@ -318,6 +312,8 @@ def mutable(self, schema: Schema) -> bool:
 
 
 class CollectionType(Type):
+    collection_name: ClassVar[str]
+
     if TYPE_CHECKING:
         _mutable_cached: bool | None
 
@@ -339,7 +335,12 @@ def mutable(self, schema: Schema) -> bool:
         object.__setattr__(self, "_mutable_cached", mut)  # noqa: PLC2801
         return mut
 
-    def get_id_and_name(self, element_type: Type) -> tuple[str, str]:
+    def get_id_and_name(
+        self,
+        element_type: Type,
+        *,
+        schema: Mapping[str, Type],
+    ) -> tuple[str, str]:
         cls = type(self)
         raise NotImplementedError(f"{cls.__qualname__}.get_id_and_name()")
 
@@ -349,14 +350,11 @@ 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]
-            )
+    def get_type_name(self, schema: Schema) -> TypeName:
+        return ParametricTypeName(
+            self.schemapath,
+            [self.get_element_type(schema).get_type_name(schema)],
+        )
 
     @functools.cached_property
     def _element_type_id(self) -> str:
@@ -386,11 +384,10 @@ def specialize(
             element_spec,
             schema=schema,
         )
-        id_, name = self.get_id_and_name(element_type)
+        id_, _ = self.get_id_and_name(element_type, schema=schema)
         return dataclasses.replace(
             self,
             id=id_,
-            name=name,
             element_type=element_type,
         )
 
@@ -443,7 +440,10 @@ def mutable(self, schema: Schema) -> bool:
         return mut
 
     def get_id_and_name(
-        self, element_types: tuple[Type, ...]
+        self,
+        element_types: tuple[Type, ...],
+        *,
+        schema: Mapping[str, Type],
     ) -> tuple[str, str]:
         cls = type(self)
         raise NotImplementedError(f"{cls.__qualname__}.get_id_and_name()")
@@ -454,18 +454,14 @@ 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
-                ],
-            )
+    def get_type_name(self, schema: Schema) -> TypeName:
+        return ParametricTypeName(
+            self.schemapath,
+            [
+                element_type.get_type_name(schema)
+                for element_type in self.get_element_types(schema)
+            ],
+        )
 
     @functools.cached_property
     def _element_type_ids(self) -> list[str]:
@@ -507,11 +503,10 @@ def specialize(
                 element_types.append(element_type)
 
         element_types_tup = tuple(element_types)
-        id_, name = self.get_id_and_name(element_types_tup)
+        id_, _ = self.get_id_and_name(element_types_tup, schema=schema)
         return dataclasses.replace(
             self,
             id=id_,
-            name=name,
             element_types=element_types_tup,
         )
 
@@ -563,6 +558,8 @@ def _assignable_from(
 
 @struct
 class ArrayType(HomogeneousCollectionType):
+    collection_name: ClassVar[str] = "std::array"
+
     array_element_id: str
 
     is_object: Literal[False]
@@ -582,13 +579,22 @@ def kind(self) -> Literal[TypeKind.Array]:
     def _element_type_id(self) -> str:
         return self.array_element_id
 
-    def get_id_and_name(self, element_type: Type) -> tuple[str, str]:
-        id_, _ = _edgeql.get_array_type_id_and_name(element_type.type_name)
+    def get_id_and_name(
+        self,
+        element_type: Type,
+        *,
+        schema: Mapping[str, Type],
+    ) -> tuple[str, str]:
+        id_, _ = _edgeql.get_array_type_id_and_name(
+            element_type.get_type_name(schema)
+        )
         return str(id_), "std::array"
 
 
 @struct
 class RangeType(HomogeneousCollectionType):
+    collection_name: ClassVar[str] = "std::range"
+
     is_object: Literal[False]
     is_scalar: Literal[False]
     is_array: Literal[False]
@@ -608,13 +614,22 @@ def kind(self) -> Literal[TypeKind.Range]:
     def _element_type_id(self) -> str:
         return self.range_element_id
 
-    def get_id_and_name(self, element_type: Type) -> tuple[str, str]:
-        id_, _ = _edgeql.get_range_type_id_and_name(element_type.type_name)
+    def get_id_and_name(
+        self,
+        element_type: Type,
+        *,
+        schema: Mapping[str, Type],
+    ) -> tuple[str, str]:
+        id_, _ = _edgeql.get_range_type_id_and_name(
+            element_type.get_type_name(schema)
+        )
         return str(id_), "std::range"
 
 
 @struct
 class MultiRangeType(HomogeneousCollectionType):
+    collection_name: ClassVar[str] = "std::multirange"
+
     is_object: Literal[False]
     is_scalar: Literal[False]
     is_array: Literal[False]
@@ -634,9 +649,14 @@ def kind(self) -> Literal[TypeKind.MultiRange]:
     def _element_type_id(self) -> str:
         return self.multirange_element_id
 
-    def get_id_and_name(self, element_type: Type) -> tuple[str, str]:
+    def get_id_and_name(
+        self,
+        element_type: Type,
+        *,
+        schema: Mapping[str, Type],
+    ) -> tuple[str, str]:
         id_, _ = _edgeql.get_multirange_type_id_and_name(
-            element_type.type_name
+            element_type.get_type_name(schema)
         )
         return str(id_), "std::multirange"
 
@@ -658,6 +678,8 @@ def _element_type_ids(self) -> list[str]:
 
 @struct
 class TupleType(_TupleType):
+    collection_name: ClassVar[str] = "std::tuple"
+
     is_object: Literal[False]
     is_scalar: Literal[False]
     is_array: Literal[False]
@@ -672,16 +694,21 @@ def kind(self) -> Literal[TypeKind.Tuple]:
         return TypeKind.Tuple
 
     def get_id_and_name(
-        self, element_types: tuple[Type, ...]
+        self,
+        element_types: tuple[Type, ...],
+        *,
+        schema: Mapping[str, Type],
     ) -> tuple[str, str]:
         id_, _ = _edgeql.get_tuple_type_id_and_name(
-            [el.type_name for el in element_types]
+            [el.get_type_name(schema) for el in element_types]
         )
         return str(id_), "std::tuple"
 
 
 @struct
 class NamedTupleType(_TupleType):
+    collection_name: ClassVar[str] = "std::tuple"
+
     is_object: Literal[False]
     is_scalar: Literal[False]
     is_array: Literal[False]
@@ -696,11 +723,14 @@ def kind(self) -> Literal[TypeKind.NamedTuple]:
         return TypeKind.NamedTuple
 
     def get_id_and_name(
-        self, element_types: tuple[Type, ...]
+        self,
+        element_types: tuple[Type, ...],
+        *,
+        schema: Mapping[str, Type],
     ) -> tuple[str, str]:
         id_, _ = _edgeql.get_named_tuple_type_id_and_name(
             {
-                el.name: el_type.type_name
+                el.name: el_type.get_type_name(schema)
                 for el, el_type in zip(
                     self.tuple_elements, element_types, strict=True
                 )
@@ -893,7 +923,7 @@ def fetch_types(
         cls = _kind_to_class[kind_of_type(t)]
         replace: dict[str, Any] = {}
         if issubclass(cls, CollectionType):
-            replace["name"] = _edgeql.unmangle_unqual_name(t.name)
+            replace["name"] = cls.collection_name
         vt = _dataclass_extras.coerce_to_dataclass(
             cls,
             t,