Fir

class FortranVariableFlags(Enum):
    NOATTRIBUTES = (
        "None"  # First character is meant to be capitalised unlike the others
    )
    ALLOCATABLE = "allocatable"
    ASYNCHRONOUS = "asynchronous"
    BIND_C = "bind_c"
    CONTIGUOUS = "contiguous"
    INTENT_IN = "intent_in"
    INTENT_INOUT = "intent_inout"
    INTENT_OUT = "intent_out"
    OPTIONAL = "optional"
    PARAMETER = "parameter"
    POINTER = "pointer"
    TARGET = "target"
    VALUE = "value"
    VOLATILE = "volatile"
    HOSTASSOC = "host_assoc"
    INTERNALASSOC = "internal_assoc"
    CRAY_POINTER = "cray_pointer"
    CRAY_POINTEE = "cray_pointee"

    @staticmethod
    def try_parse(parser: AttrParser) -> set[FortranVariableFlags] | None:
        for option in FortranVariableFlags:
            if parser.parse_optional_characters(option.value) is not None:
                return {option}

        return None

@dataclass(frozen=True)
class FortranVariableFlagsAttrBase(Data[tuple[FortranVariableFlags, ...]]):
    @property
    def flags(self) -> set[FortranVariableFlags]:
        """
        Returns a copy of the Fortran variable flags.
        """
        return set(self.data)

    def __init__(self, flags: Sequence[FortranVariableFlags]):
        flags_: set[FortranVariableFlags] = set(flags)

        super().__init__(tuple(flags_))

    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> tuple[FortranVariableFlags, ...]:
        with parser.in_angle_brackets():
            flags = FortranVariableFlags.try_parse(parser)
            if flags is None:
                return tuple()

            while parser.parse_optional_punctuation(",") is not None:
                flag = parser.expect(
                    lambda: FortranVariableFlags.try_parse(parser),
                    "fortran variable flag expected",
                )
                flags.update(flag)

            return tuple(flags)

    def print_parameter(self, printer: Printer):
        with printer.in_angle_brackets():
            flags = self.data
            # make sure we emit flags in a consistent order
            printer.print_list(
                tuple(flag.value for flag in FortranVariableFlags if flag in flags),
                printer.print_string,
                ",",
            )

@irdl_attr_definition
class FortranVariableFlagsAttr(FortranVariableFlagsAttrBase):
    name = "fir.var_attrs"

class FortranProcedureFlags(Enum):
    """
    Fortran procedure attributes (F2023 15.6.2.1). BIND attribute (18.3.7)
    is also tracked in the same enum."""

    NOATTRIBUTES = "none"
    ELEMENTAL = "elemental"
    PURE = "pure"
    NON_RECURSIVE = "non_recursive"
    SIMPLE = "simple"
    BIND_C = "bind_c"

    @staticmethod
    def try_parse(parser: AttrParser) -> set[FortranProcedureFlags] | None:
        for option in FortranProcedureFlags:
            if parser.parse_optional_characters(option.value) is not None:
                return {option}
        return None

@dataclass(frozen=True)
class FortranProcedureFlagsAttrBase(Data[tuple[FortranProcedureFlags, ...]]):
    @property
    def flags(self) -> set[FortranProcedureFlags]:
        return set(self.data)

    def __init__(self, flags: Sequence[FortranProcedureFlags]):
        super().__init__(tuple(set(flags)))

    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> tuple[FortranProcedureFlags, ...]:
        with parser.in_angle_brackets():
            flags = FortranProcedureFlags.try_parse(parser)
            if flags is None:
                return tuple()
            while parser.parse_optional_punctuation(",") is not None:
                flag = parser.expect(
                    lambda: FortranProcedureFlags.try_parse(parser),
                    "fortran procedure flag expected",
                )
                flags.update(flag)
            return tuple(flags)

    def print_parameter(self, printer: Printer):
        with printer.in_angle_brackets():
            flags = self.data
            printer.print_list(
                tuple(flag.value for flag in FortranProcedureFlags if flag in flags),
                printer.print_string,
                ",",
            )

@irdl_attr_definition
class FortranProcedureFlagsAttr(FortranProcedureFlagsAttrBase):
    name = "fir.proc_attrs"

class FortranInlineFlags(Enum):
    """Fortran inline hint attributes for fir.call."""

    NONE = "none"
    NO_INLINE = "no_inline"
    ALWAYS_INLINE = "always_inline"
    INLINE_HINT = "inline_hint"

    @staticmethod
    def try_parse(parser: AttrParser) -> set[FortranInlineFlags] | None:
        for option in FortranInlineFlags:
            if parser.parse_optional_characters(option.value) is not None:
                return {option}
        return None

@dataclass(frozen=True)
class FortranInlineFlagsAttrBase(Data[tuple[FortranInlineFlags, ...]]):
    @property
    def flags(self) -> set[FortranInlineFlags]:
        return set(self.data)

    def __init__(self, flags: Sequence[FortranInlineFlags]):
        super().__init__(tuple(set(flags)))

    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> tuple[FortranInlineFlags, ...]:
        with parser.in_angle_brackets():
            flags = FortranInlineFlags.try_parse(parser)
            if flags is None:
                return tuple()
            while parser.parse_optional_punctuation(",") is not None:
                flag = parser.expect(
                    lambda: FortranInlineFlags.try_parse(parser),
                    "fortran inline flag expected",
                )
                flags.update(flag)
            return tuple(flags)

    def print_parameter(self, printer: Printer):
        with printer.in_angle_brackets():
            flags = self.data
            printer.print_list(
                tuple(flag.value for flag in FortranInlineFlags if flag in flags),
                printer.print_string,
                ",",
            )

@irdl_attr_definition
class FortranInlineFlagsAttr(FortranInlineFlagsAttrBase):
    name = "fir.inline_attrs"

class PackArrayHeuristics(Enum):
    """Optimization heuristics for fir.pack_array."""

    NONE = "none"
    LOOP_ONLY = "loop_only"

    @staticmethod
    def try_parse(parser: AttrParser) -> set[PackArrayHeuristics] | None:
        for option in PackArrayHeuristics:
            if parser.parse_optional_characters(option.value) is not None:
                return {option}
        return None

@dataclass(frozen=True)
class PackArrayHeuristicsAttrBase(Data[tuple[PackArrayHeuristics, ...]]):
    @property
    def flags(self) -> set[PackArrayHeuristics]:
        return set(self.data)

    def __init__(self, flags: Sequence[PackArrayHeuristics]):
        super().__init__(tuple(set(flags)))

    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> tuple[PackArrayHeuristics, ...]:
        with parser.in_angle_brackets():
            flags = PackArrayHeuristics.try_parse(parser)
            if flags is None:
                return tuple()
            while parser.parse_optional_punctuation(",") is not None:
                flag = parser.expect(
                    lambda: PackArrayHeuristics.try_parse(parser),
                    "pack_array heuristic expected",
                )
                flags.update(flag)
            return tuple(flags)

    def print_parameter(self, printer: Printer):
        with printer.in_angle_brackets():
            flags = self.data
            printer.print_list(
                tuple(flag.value for flag in PackArrayHeuristics if flag in flags),
                printer.print_string,
                ",",
            )

@irdl_attr_definition
class PackArrayHeuristicsAttr(PackArrayHeuristicsAttrBase):
    name = "fir.pack_array_heuristics"

class ReduceOperator(Enum):
    """
    Intrinsic reduction operations for DO CONCURRENT REDUCE.
    Upstream this is an I32BitEnumAttr; in practice each reduction
    declaration selects a single operation, so a single value is stored."""

    ADD = "add"
    MULTIPLY = "multiply"
    AND = "and"
    OR = "or"
    EQV = "eqv"
    NEQV = "neqv"
    MAX = "max"
    MIN = "min"
    IAND = "iand"
    IOR = "ior"
    IEOR = "ieor"

    @staticmethod
    def try_parse(parser: AttrParser) -> ReduceOperator | None:
        for option in ReduceOperator:
            if parser.parse_optional_characters(option.value) is not None:
                return option
        return None

@dataclass(frozen=True)
class ReduceAttrBase(Data[ReduceOperator]):
    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> ReduceOperator:
        with parser.in_angle_brackets():
            return parser.expect(
                lambda: ReduceOperator.try_parse(parser),
                "reduce operation expected",
            )

    def print_parameter(self, printer: Printer):
        with printer.in_angle_brackets():
            printer.print_string(self.data.value)

@irdl_attr_definition
class ReduceAttr(ReduceAttrBase):
    name = "fir.reduce_attr"

class LocationKind(Enum):
    """Flang location kind for debug info."""

    BASE = "base"
    INCLUSION = "inclusion"

    @staticmethod
    def try_parse(parser: AttrParser) -> LocationKind | None:
        for option in LocationKind:
            if parser.parse_optional_characters(option.value) is not None:
                return option
        return None

@dataclass(frozen=True)
class LocationKindAttrBase(Data[LocationKind]):
    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> LocationKind:
        with parser.in_angle_brackets():
            return parser.expect(
                lambda: LocationKind.try_parse(parser),
                "location kind expected",
            )

    def print_parameter(self, printer: Printer):
        with printer.in_angle_brackets():
            printer.print_string(self.data.value)

@irdl_attr_definition
class LocationKindAttr(LocationKindAttrBase):
    name = "fir.loc_kind"

@dataclass(frozen=True)
class LocationKindArrayAttrBase(Data[tuple[LocationKind, ...]]):
    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> tuple[LocationKind, ...]:
        with parser.in_square_brackets():
            kinds: list[LocationKind] = []
            first = LocationKind.try_parse(parser)
            if first is None:
                return tuple()
            kinds.append(first)
            while parser.parse_optional_punctuation(",") is not None:
                kinds.append(
                    parser.expect(
                        lambda: LocationKind.try_parse(parser),
                        "location kind expected",
                    )
                )
            return tuple(kinds)

    def print_parameter(self, printer: Printer):
        with printer.in_square_brackets():
            printer.print_list(
                tuple(k.value for k in self.data),
                printer.print_string,
                ",",
            )

@irdl_attr_definition
class LocationKindArrayAttr(LocationKindArrayAttrBase):
    name = "fir.loc_kind_array"

class LocalitySpecifierType(Enum):
    """Locality kind for fir.local: LOCAL vs LOCAL_INIT."""

    LOCAL = "local"
    LOCAL_INIT = "local_init"

    @staticmethod
    def try_parse(parser: AttrParser) -> LocalitySpecifierType | None:
        for option in LocalitySpecifierType:
            if parser.parse_optional_characters(option.value) is not None:
                return option
        return None

@dataclass(frozen=True)
class LocalitySpecifierTypeAttrBase(Data[LocalitySpecifierType]):
    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> LocalitySpecifierType:
        parser.parse_punctuation("{")
        parser.parse_keyword("type")
        parser.parse_punctuation("=")
        value = parser.expect(
            lambda: LocalitySpecifierType.try_parse(parser),
            "locality specifier type expected",
        )
        parser.parse_punctuation("}")
        return value

    def print_parameter(self, printer: Printer):
        printer.print_string("{type = ")
        printer.print_string(self.data.value)
        printer.print_string("}")

@irdl_attr_definition
class LocalitySpecifierTypeAttr(LocalitySpecifierTypeAttrBase):
    name = "fir.locality_specifier_type"

@irdl_attr_definition
class UseRenameAttr(ParametrizedAttribute):
    """A single rename mapping for a Fortran USE statement: local_name => module_var."""

    name = "fir.use_rename"

    local_name: StringAttr
    symbol: SymbolRefAttr

@irdl_attr_definition
class OpenACCSafeTempArrayCopyAttr(ParametrizedAttribute):
    """Marker attribute implementing SafeTempArrayCopyAttrInterface for OpenACC."""

    name = "fir.acc_safe_temp_array_copy"

@irdl_attr_definition
class OpenMPSafeTempArrayCopyAttr(ParametrizedAttribute):
    """Marker attribute implementing SafeTempArrayCopyAttrInterface for OpenMP."""

    name = "fir.omp_safe_temp_array_copy"