Cleaned up Serialization code.

src/kirin/dialects/func/attrs.py

@@ -4,9 +4,9 @@
 from kirin import types
 from kirin.ir import Method, Attribute
 from kirin.print.printer import Printer
+from kirin.serialization.core.serializationunit import SerializationUnit
 
 if TYPE_CHECKING:
-    from kirin.serialization.base.serializationunit import SerializationUnit
     from kirin.serialization.base.serializer import Serializer
     from kirin.serialization.base.deserializer import Deserializer
 
@@ -50,7 +50,15 @@ def __eq__(self, value: object) -> bool:
         return self.inputs == value.inputs and self.output == value.output
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_signature(self)
+        return SerializationUnit(
+            kind="signature",
+            module_name=self.__module__,
+            class_name=self.__class__.__name__,
+            data={
+                "inputs": serializer.serialize_tuple(self.inputs),
+                "output": serializer.serialize(self.output),
+            },
+        )
 
     def is_structurally_equal(
         self,
@@ -63,4 +71,6 @@ def is_structurally_equal(
     def deserialize(
         cls, serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "Signature":
-        return deserializer.deserialize_signature(serUnit)
+        inputs = deserializer.deserialize(serUnit.data["inputs"])
+        output = deserializer.deserialize(serUnit.data["output"])
+        return Signature(inputs=inputs, output=output)

src/kirin/dialects/ilist/runtime.py

@@ -1,24 +1,26 @@
 # TODO: replace with something faster
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, overload
+from typing import Any, Generic, TypeVar, overload
 from dataclasses import dataclass
 from collections.abc import Sequence
 
 from kirin import ir, types
 from kirin.print.printer import Printer
+from kirin.serialization.base.serializer import Serializer
+from kirin.serialization.base.deserializer import Deserializer
+from kirin.serialization.core.serializationunit import SerializationUnit
 
-if TYPE_CHECKING:
-    from kirin.serialization.base.serializer import Serializer
-    from kirin.serialization.base.deserializer import Deserializer
-    from kirin.serialization.base.serializationunit import SerializationUnit
+from ._dialect import dialect
 
 T = TypeVar("T")
 L = TypeVar("L")
 
 
 @dataclass
+@dialect.register
 class IList(ir.Data[Sequence[T]], Sequence[T], Generic[T, L]):
     """A simple immutable list."""
 
+    name = "IList"
     data: Sequence[T]
     elem: types.TypeAttribute = types.Any
 
@@ -105,10 +107,20 @@ def is_structurally_equal(
         )
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_ilist(self)
+        return SerializationUnit(
+            kind="ilist",
+            module_name=dialect.name,
+            class_name=IList.__name__,
+            data={
+                "data": serializer.serialize(self.data),
+                "elem": serializer.serialize_attribute(self.elem),
+            },
+        )
 
     @classmethod
     def deserialize(
         cls, serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "IList":
-        return deserializer.deserialize_ilist(serUnit)
+        items = deserializer.deserialize(serUnit.data["data"])
+        elem = deserializer.deserialize(serUnit.data["elem"])
+        return IList(items, elem=elem)

src/kirin/interp/abc.py

@@ -226,8 +226,10 @@ def frame_call_region(
             InterpreterError: if cannot find a matching implementation for the region.
         """
         region_trait = node.get_present_trait(ir.RegionInterpretationTrait)
+
         how = self.registry.get(Signature(region_trait))
         if how is None:
+
             raise InterpreterError(
                 f"Interpreter {self.__class__.__name__} does not "
                 f"support {node} using {region_trait} convention"

src/kirin/ir/attrs/py.py

@@ -5,9 +5,11 @@
 
 from kirin.print import Printer
 from kirin.ir.attrs.abc import Attribute
+from kirin.serialization.core.serializable import Serializable
+from kirin.serialization.core.supportedtypes import SUPPORTED_PYTHON_TYPES
+from kirin.serialization.core.serializationunit import SerializationUnit
 
 if TYPE_CHECKING:
-    from kirin.serialization.base.serializationunit import SerializationUnit
     from kirin.serialization.base.serializer import Serializer
     from kirin.serialization.base.deserializer import Deserializer
 
@@ -70,17 +72,37 @@ def is_structurally_equal(
         if isinstance(self.data, StructurallyEqual) and isinstance(
             other.data, StructurallyEqual
         ):
+
             return self.data.is_structurally_equal(other.data, context=context)
         return self.data == other.data
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_pyattr(self)
+        if not (
+            isinstance(self.data, SUPPORTED_PYTHON_TYPES)
+            or isinstance(self.data, Serializable)
+        ):
+            raise TypeError(
+                f"Cannot serialize data of type {type(self.data)}. "
+                "Data must be one of the supported Python types."
+            )
+
+        return SerializationUnit(
+            kind="pyattr",
+            module_name=self.__module__,
+            class_name=self.__class__.__name__,
+            data={
+                "data": serializer.serialize(self.data),
+                "pytype": serializer.serialize_attribute(self.type),
+            },
+        )
 
     @classmethod
     def deserialize(
         cls: Type["PyAttr"], serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "PyAttr":
-        return deserializer.deserialize_pyattr(serUnit)
+        pytype = deserializer.deserialize(serUnit.data["pytype"])
+        value = deserializer.deserialize(serUnit.data["data"])
+        return PyAttr(value, pytype=pytype)
 
 
 @runtime_checkable

src/kirin/ir/attrs/types.py

@@ -7,8 +7,11 @@
 from beartype.door import TupleVariableTypeHint  # type: ignore
 from beartype.door import TypeHint, ClassTypeHint, LiteralTypeHint, TypeVarTypeHint
 
+from kirin.serialization.core.serializable import Serializable
+from kirin.serialization.core.supportedtypes import SUPPORTED_PYTHON_TYPES
+from kirin.serialization.core.serializationunit import SerializationUnit
+
 if TYPE_CHECKING:
-    from kirin.serialization.base.serializationunit import SerializationUnit
     from kirin.serialization.base.serializer import Serializer
     from kirin.serialization.base.deserializer import Deserializer
 
@@ -111,13 +114,18 @@ def is_structurally_equal(
         return isinstance(other, AnyType)
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_anytype(self)
+        return SerializationUnit(
+            kind="type-attribute",
+            module_name=self.__module__,
+            class_name=self.__class__.__name__,
+            data=dict(),
+        )
 
     @classmethod
     def deserialize(
         cls, serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "AnyType":
-        return deserializer.deserialize_anytype(serUnit)
+        return AnyType()
 
 
 @typing.final
@@ -139,13 +147,18 @@ def is_structurally_equal(
         return isinstance(other, BottomType)
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_bottomtype(self)
+        return SerializationUnit(
+            kind="type-attribute",
+            module_name=self.__module__,
+            class_name=self.__class__.__name__,
+            data=dict(),
+        )
 
     @classmethod
     def deserialize(
         cls, serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "BottomType":
-        return deserializer.deserialize_bottomtype(serUnit)
+        return BottomType()
 
 
 class PyClassMeta(TypeAttributeMeta):
@@ -239,13 +252,26 @@ def is_structurally_equal(
         return isinstance(other, PyClass) and self.typ == other.typ
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_pyclass(self)
+        return SerializationUnit(
+            kind="type-attribute",
+            module_name=self.__module__,
+            class_name=self.__class__.__name__,
+            data=dict(
+                typ=serializer.serialize_type(self.typ),
+                display_name=serializer.serialize_str(self.display_name),
+                prefix=serializer.serialize_str(self.prefix),
+            ),
+        )
 
     @classmethod
     def deserialize(
         cls, serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "PyClass":
-        return deserializer.deserialize_pyclass(serUnit)
+        return PyClass(
+            typ=deserializer.deserialize(serUnit.data["typ"]),
+            display_name=deserializer.deserialize(serUnit.data.get("display_name", "")),
+            prefix=deserializer.deserialize(serUnit.data.get("prefix", "")),
+        )
 
 
 class LiteralMeta(TypeAttributeMeta):
@@ -318,13 +344,31 @@ def is_structurally_equal(
         )
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_literal(self)
+        if not (
+            isinstance(self.data, SUPPORTED_PYTHON_TYPES)
+            or isinstance(self.data, Serializable)
+        ):
+            raise ValueError(
+                f"Unsupported data type {type(self.data)} for serialization. Implement 'serialize' method."
+            )
+        else:
+            return SerializationUnit(
+                kind="type-attribute",
+                module_name=self.__module__,
+                class_name=self.__class__.__name__,
+                data={
+                    "value": serializer.serialize(self.data),
+                    "type": serializer.serialize_attribute(self.type),
+                },
+            )
 
     @classmethod
     def deserialize(
         cls, serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "Literal":
-        return deserializer.deserialize_literal(serUnit)
+        d = deserializer.deserialize(serUnit.data["value"])
+        type_attr = deserializer.deserialize(serUnit.data["type"])
+        return Literal(d, type_attr)
 
 
 @typing.final
@@ -390,13 +434,19 @@ def is_structurally_equal(
         return isinstance(other, Union) and self.types == other.types
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_union(self)
+        return SerializationUnit(
+            kind="type-attribute",
+            module_name=self.__module__,
+            class_name=self.__class__.__name__,
+            data={"types": serializer.serialize_frozenset(self.types)},
+        )
 
     @classmethod
     def deserialize(
         cls, serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "Union":
-        return deserializer.deserialize_union(serUnit)
+        ty = deserializer.deserialize_frozenset(serUnit.data["types"])
+        return Union(ty)
 
 
 @typing.final
@@ -438,13 +488,23 @@ def is_structurally_equal(
         )
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_typevar(self)
+        return SerializationUnit(
+            kind="type-attribute",
+            module_name=self.__module__,
+            class_name=self.__class__.__name__,
+            data={
+                "varname": serializer.serialize_str(self.varname),
+                "bound": serializer.serialize_attribute(self.bound),
+            },
+        )
 
     @classmethod
     def deserialize(
         cls, serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "TypeVar":
-        return deserializer.deserialize_typevar(serUnit)
+        varname = deserializer.deserialize(serUnit.data["varname"])
+        bound = deserializer.deserialize(serUnit.data["bound"])
+        return TypeVar(varname, bound)
 
 
 @typing.final
@@ -472,13 +532,19 @@ def is_structurally_equal(
         return isinstance(other, Vararg) and self.typ.is_structurally_equal(other.typ)
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_vararg(self)
+        return SerializationUnit(
+            kind="type-attribute",
+            module_name=self.__module__,
+            class_name=self.__class__.__name__,
+            data={"typ": serializer.serialize_attribute(self.typ)},
+        )
 
     @classmethod
     def deserialize(
         cls, serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "Vararg":
-        return deserializer.deserialize_vararg(serUnit)
+        typ = deserializer.deserialize(serUnit.data["typ"])
+        return Vararg(typ)
 
 
 TypeVarValue: typing.TypeAlias = TypeAttribute | Vararg | list
@@ -627,13 +693,27 @@ def is_structurally_equal(
         return False
 
     def serialize(self, serializer: "Serializer") -> "SerializationUnit":
-        return serializer.serialize_generic(self)
+        return SerializationUnit(
+            kind="type-attribute",
+            module_name=self.__module__,
+            class_name=self.__class__.__name__,
+            data={
+                "body": serializer.serialize(self.body),
+                "vars": serializer.serialize_tuple(self.vars),
+                "vararg": serializer.serialize(self.vararg),
+            },
+        )
 
     @classmethod
     def deserialize(
         cls, serUnit: "SerializationUnit", deserializer: "Deserializer"
     ) -> "Generic":
-        return deserializer.deserialize_generic(serUnit)
+        body = deserializer.deserialize(serUnit.data["body"])
+        vars = deserializer.deserialize_tuple(serUnit.data["vars"])
+        vararg = deserializer.deserialize(serUnit.data["vararg"])
+        out = Generic(body, *vars)
+        out.vararg = vararg
+        return out
 
 
 def _typeparams_list2tuple(args: tuple[TypeVarValue, ...]) -> tuple[TypeOrVararg, ...]:

src/kirin/ir/dialect.py

@@ -17,7 +17,7 @@
     from kirin.lowering.python.dialect import FromPythonAST
     from kirin.serialization.base.serializer import Serializer
     from kirin.serialization.base.deserializer import Deserializer
-    from kirin.serialization.base.serializationunit import SerializationUnit
+    from kirin.serialization.core.serializationunit import SerializationUnit
 
 
 @dataclass