Builder

@dataclass
class PyASTBuilder:
    """Builder for xDSL modules from aspects of a Python function."""

    type_registry: TypeRegistry
    """Mappings between source code and IR type."""

    function_registry: FunctionRegistry
    """Mappings between functions and their operation types."""

    literal_registry: LiteralRegistry
    """Mappings between literal types and their operation constructors."""

    file: str | None
    """The file path of the function being built."""

    globals: dict[str, Any]
    """Global information for the function being built, including all the imports."""

    function_ast: ast.FunctionDef
    """The AST tree for the function being built."""

    build_context: Context
    """The xDSL context to use when applying transformations to the built module."""

    post_transforms: PassPipeline
    """An ordered list of passes and callbacks to apply to the built module."""

    function_definition_constructor: FunctionDefinitionConstructor = build_func
    """Construct the operation for each function."""

    return_constructor: ReturnConstructor = build_return
    """Construct return operations, optionally omitting the terminator."""

    def build(self) -> ModuleOp:
        """Build a module from the builder state."""
        # Convert the Python AST into xDSL IR objects
        type_converter = TypeConverter(
            self.globals,
            self.type_registry,
            self.function_registry,
            self.literal_registry,
        )
        module = ModuleOp([])
        CodeGenerationVisitor(module, self.file).visit(self.function_ast)

        # Lower the generated `py` operations to the registered operations. This is
        # done here rather than as a post transform because it needs the function's
        # globals as well as the registries, and the module only verifies once lowered.
        PyLowering(
            type_converter,
            self.file,
            self.function_definition_constructor,
            self.return_constructor,
        ).lower(module)
        module.verify()

        self.post_transforms.apply(self.build_context.clone(), module)
        return module