Attribute

Attribute dataclass

Bases: ABC

A compile-time value. Attributes are used to represent SSA variable types, and can be attached on operations to give extra information.

Source code in xdsl/ir/core.py

@dataclass(frozen=True)
class Attribute(ABC):
    """
    A compile-time value.
    Attributes are used to represent SSA variable types, and can be attached
    on operations to give extra information.
    """

    name: ClassVar[str] = field(init=False, repr=False)
    """The attribute name should be a static field in the attribute classes."""

    def __post_init__(self):
        self._verify()
        if not isinstance(self, Data | ParametrizedAttribute):
            raise TypeError("Attributes should only be Data or ParameterizedAttribute")

    def _verify(self):
        self.verify()

    def verify(self) -> None:
        """
        Check that the attribute parameters satisfy the expected invariants.
        Raise a VerifyException otherwise.
        """
        pass

    def __str__(self) -> str:
        from xdsl.printer import Printer

        res = StringIO()
        printer = Printer(stream=res)
        printer.print_attribute(self)
        return res.getvalue()

name: str = field(init=False, repr=False) class-attribute

The attribute name should be a static field in the attribute classes.

verify() -> None

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Source code in xdsl/ir/core.py

def verify(self) -> None:
    """
    Check that the attribute parameters satisfy the expected invariants.
    Raise a VerifyException otherwise.
    """
    pass

Data dataclass

Bases: Generic[DataElement], Attribute, ABC

An attribute represented by a Python structure.

Source code in xdsl/ir/core.py

@dataclass(frozen=True)
class Data(Generic[DataElement], Attribute, ABC):
    """An attribute represented by a Python structure."""

    data: DataElement

    @classmethod
    def new(cls: type[Self], params: Any) -> Self:
        """
        Create a new `Data` given its parameter.

        The `params` argument should be of the same type as the `Data` generic
        argument.

        This function should be preferred over `__init__` when instantiating
        attributes in a generic way (i.e., without knowing their concrete type
        statically).
        """
        # Create the new attribute object, without calling its __init__.
        # We do this to allow users to redefine their own __init__.
        attr = cls.__new__(cls)

        # Call the __init__ of Data, which will set the parameters field.
        Data.__init__(attr, params)  # pyright: ignore[reportUnknownMemberType]
        return attr

    @classmethod
    @abstractmethod
    def parse_parameter(cls, parser: AttrParser) -> DataElement:
        """Parse the attribute parameter."""

    @abstractmethod
    def print_parameter(self, printer: Printer) -> None:
        """Print the attribute parameter."""

data: DataElement instance-attribute

print_parameter(printer: Printer) -> None abstractmethod

Print the attribute parameter.

Source code in xdsl/ir/core.py

@abstractmethod
def print_parameter(self, printer: Printer) -> None:
    """Print the attribute parameter."""

parse_parameter(parser: AttrParser) -> DataElement abstractmethod classmethod

Parse the attribute parameter.

Source code in xdsl/ir/core.py

@classmethod
@abstractmethod
def parse_parameter(cls, parser: AttrParser) -> DataElement:
    """Parse the attribute parameter."""

ParametrizedAttribute dataclass

Bases: Attribute

An attribute parametrized by other attributes.

Source code in xdsl/ir/core.py

@dataclass(frozen=True, init=False)
class ParametrizedAttribute(Attribute):
    """An attribute parametrized by other attributes."""

    parameters: tuple[Attribute, ...] = field()

    def __init__(self, parameters: Sequence[Attribute] = ()):
        object.__setattr__(self, "parameters", tuple(parameters))
        super().__init__()

    @classmethod
    def new(cls: type[Self], params: Sequence[Attribute]) -> Self:
        """
        Create a new `ParametrizedAttribute` given its parameters.

        This function should be preferred over `__init__` when instantiating
        attributes in a generic way (i.e., without knowing their concrete type
        statically).
        """
        # Create the new attribute object, without calling its __init__.
        # We do this to allow users to redefine their own __init__.
        attr = cls.__new__(cls)

        # Call the __init__ of ParametrizedAttribute, which will set the
        # parameters field.
        ParametrizedAttribute.__init__(attr, tuple(params))
        return attr

    @classmethod
    def parse_parameters(cls, parser: AttrParser) -> Sequence[Attribute]:
        """Parse the attribute parameters."""
        return parser.parse_paramattr_parameters()

    def print_parameters(self, printer: Printer) -> None:
        """Print the attribute parameters."""
        printer.print_paramattr_parameters(self.parameters)

    @classmethod
    def get_irdl_definition(cls) -> ParamAttrDef:
        """Get the IRDL attribute definition."""
        ...

    def _verify(self):
        # Verifier generated by irdl_attr_def
        t: type[ParametrizedAttribute] = type(self)
        attr_def = t.get_irdl_definition()
        attr_def.verify(self)
        super()._verify()

parameters: tuple[Attribute, ...] = field() class-attribute instance-attribute

print_parameters(printer: Printer) -> None

Print the attribute parameters.

Source code in xdsl/ir/core.py

def print_parameters(self, printer: Printer) -> None:
    """Print the attribute parameters."""
    printer.print_paramattr_parameters(self.parameters)

parse_parameters(parser: AttrParser) -> Sequence[Attribute] classmethod

Parse the attribute parameters.

Source code in xdsl/ir/core.py

@classmethod
def parse_parameters(cls, parser: AttrParser) -> Sequence[Attribute]:
    """Parse the attribute parameters."""
    return parser.parse_paramattr_parameters()

get_irdl_definition() -> ParamAttrDef classmethod

Get the IRDL attribute definition.

Source code in xdsl/ir/core.py

@classmethod
def get_irdl_definition(cls) -> ParamAttrDef:
    """Get the IRDL attribute definition."""
    ...

TypedAttribute dataclass

Bases: ParametrizedAttribute, ABC

An attribute with a type.

Source code in xdsl/ir/core.py

class TypedAttribute(ParametrizedAttribute, ABC):
    """
    An attribute with a type.
    """

    @classmethod
    def get_type_index(cls) -> int: ...

    def get_type(self) -> Attribute:
        return self.parameters[self.get_type_index()]

    @staticmethod
    def parse_with_type(
        parser: AttrParser,
        type: Attribute,
    ) -> TypedAttribute:
        """
        Parse the attribute with the given type.
        """
        ...

    @abstractmethod
    def print_without_type(self, printer: Printer): ...