Class ModuleIR

mypyc/ir/module_ir.py:13–103

Intermediate representation of a module.

class ModuleIR:
    """Intermediate representation of a module."""

    def __init__(
        self,
        fullname: str,
        imports: list[str],
        functions: list[FuncIR],
        classes: list[ClassIR],
        final_names: list[tuple[str, RType]],
        type_var_names: list[str],
    ) -> None:
        self.fullname = fullname
        self.imports = imports.copy()
        self.functions = functions
        self.classes = classes
        self.final_names = final_names
        # Names of C statics used for Python 3.12 type variable objects.
        # These are only visible in the module that defined them, so no need
        # to serialize.
        self.type_var_names = type_var_names
        # Dependencies needed by the module (such as capsules or source files)
        self.dependencies: set[Dependency] = set()

    def serialize(self) -> JsonDict:
        # Serialize dependencies as a list of dicts with type information
        serialized_deps = []
        for dep in sorted(self.dependencies, key=lambda d: (type(d).__name__, str(d))):
            if isinstance(dep, Capsule):
                serialized_deps.append({"type": "Capsule", "name": dep.name})
            elif isinstance(dep, SourceDep):
                source_dep: JsonDict = {
                    "type": "SourceDep",
                    "path": dep.path,
                    "include_dirs": dep.include_dirs,
                    "internal": dep.internal,
                }
                serialized_deps.append(source_dep)
            elif isinstance(dep, HeaderDep):
                header_dep: JsonDict = {
                    "type": "HeaderDep",
                    "path": dep.path,
                    "include_dirs": dep.include_dirs,
                    "internal": dep.internal,
                }
                serialized_deps.append(header_dep)

        return {
            "fullname": self.fullname,
            "imports": self.imports,
            "functions": [f.serialize() for f in self.functions],
            "classes": [c.serialize() for c in self.classes],
            "final_names": [(k, t.serialize()) for k, t in self.final_names],
            "dependencies": serialized_deps,
        }

    @classmethod
    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> ModuleIR: