Add VTable

Author: tothtamas28

kmir/src/kmir/smir.py

@@ -404,6 +404,8 @@ def from_dict(dct: dict[str, Any]) -> GlobalAlloc:
         match dct:
             case {'Function': _}:
                 return Function.from_dict(dct)
+            case {'VTable': _}:
+                return VTable.from_dict(dct)
             case {'Static': _}:
                 return Static.from_dict(dct)
             case {'Memory': _}:
@@ -477,6 +479,154 @@ def from_dict(obj: Any) -> Virtual:
 class Shim(InstanceKind): ...
 
 
+@dataclass
+class VTable(GlobalAlloc):
+    ty: Ty
+    binder: ExistentialTraitRefBinder | None
+
+    @staticmethod
+    def from_dict(dct: dict[str, Any]) -> VTable:
+        return VTable(
+            ty=Ty(dct['VTable'][0]),
+            binder=ExistentialTraitRefBinder.from_dict(dct['VTable'][1]) if dct['VTable'][1] is not None else None,
+        )
+
+
+@dataclass
+class ExistentialTraitRefBinder:
+    value: ExistentialTraitRef
+    bound_vars: list[BoundVariableKind]
+
+    @staticmethod
+    def from_dict(dct: dict[str, Any]) -> ExistentialTraitRefBinder:
+        return ExistentialTraitRefBinder(
+            value=ExistentialTraitRef.from_dict(dct['value']),
+            bound_vars=[BoundVariableKind.from_dict(var) for var in dct['bound_vars']],
+        )
+
+
+@dataclass
+class ExistentialTraitRef:
+    def_id: DefId
+    generic_args: list[GenericArgKind]
+
+    @staticmethod
+    def from_dict(dct: dict[str, Any]) -> ExistentialTraitRef:
+        return ExistentialTraitRef(
+            def_id=DefId(dct['def_id']),
+            generic_args=[GenericArgKind.from_dict(arg) for arg in dct['generic_args']],
+        )
+
+
+@dataclass
+class BoundVariableKind(ABC):  # noqa: B024
+    @staticmethod
+    def from_dict(dct: Any) -> BoundVariableKind:
+        match dct:
+            case {'Ty': _}:
+                return BVTy.from_dict(dct)
+            case {'Region': _}:
+                return BVRegion.from_dict(dct)
+            case 'Const':
+                return BVConst()
+            case _:
+                raise ValueError(f'Invalid BoundBariableKind data: {dct}')
+
+
+@dataclass
+class BVTy(BoundVariableKind):
+    kind: BoundTyKind
+
+    @staticmethod
+    def from_dict(dct: Any) -> BVTy:
+        return BVTy(kind=BoundTyKind.from_dict(dct['Ty']))
+
+
+class BoundTyKind(ABC):  # noqa: B024
+    @staticmethod
+    def from_dict(dct: Any) -> BoundTyKind:
+        match dct:
+            case 'Anon':
+                return BTAnon()
+            case {'Param': _}:
+                return BTParam.from_dict(dct)
+            case _:
+                raise ValueError(f'Invalid BoundTyKind data: {dct}')
+
+
+@dataclass
+class BTAnon(BoundTyKind): ...
+
+
+@dataclass
+class BTParam(BoundTyKind):
+    def_id: DefId
+    name: str
+
+    @staticmethod
+    def from_dict(dct: Any) -> BTParam:
+        return BTParam(
+            def_id=DefId(dct['Param'][0]),
+            name=str(dct['Param'][1]),
+        )
+
+
+@dataclass
+class BVRegion(BoundVariableKind):
+    kind: BoundRegionKind
+
+    @staticmethod
+    def from_dict(dct: Any) -> BVRegion:
+        return BVRegion(kind=BoundRegionKind.from_dict(dct['Region']))
+
+
+class BoundRegionKind(ABC):  # noqa: B024
+    @staticmethod
+    def from_dict(dct: Any) -> BoundRegionKind:
+        match dct:
+            case 'BrAnon':
+                return BRAnon()
+            case {'BrNamed': _}:
+                return BRNamed.from_dict(dct)
+            case 'BrEnv':
+                return BREnv()
+            case _:
+                raise ValueError(f'Invalid BoundRegionKind data: {dct}')
+
+
+@dataclass
+class BRAnon(BoundRegionKind): ...
+
+
+@dataclass
+class BRNamed(BoundRegionKind):
+    def_id: DefId
+    name: str
+
+    @staticmethod
+    def from_dict(dct: Any) -> BRNamed:
+        return BRNamed(
+            def_id=DefId(dct['BrNamed'][0]),
+            name=str(dct['BrNamed'][1]),
+        )
+
+
+@dataclass
+class BREnv(BoundRegionKind): ...
+
+
+@dataclass
+class BVConst(BoundVariableKind): ...
+
+
+@dataclass
+class GenericArgKind:
+    @staticmethod
+    def from_dict(dct: dict[str, Any]) -> GenericArgKind:
+        _LOGGER.warning(f'Unparsed GenericArgKind data encountered: {dct}')
+        return GenericArgKind()
+
+
 @dataclass
 class Static(GlobalAlloc):
     def_id: DefId