Struct melior::dialect::ods::transform::ForeachMatchOperation

pub struct ForeachMatchOperation<'c> { /* private fields */ }

A foreach_match operation. Applies named sequences when a named matcher succeeds.

Given a pair of co-indexed lists of transform dialect symbols (such as transform.named_sequence), walks the payload IR associated with the root handle and interprets the symbols as matcher/action pairs by applying the body of the corresponding symbol definition. The symbol from the first list is the matcher part: if it results in a silenceable error, the error is silenced and the next matcher is attempted. Definite failures from any matcher stop the application immediately and are propagated unconditionally. If none of the matchers succeeds, the next payload operation in walk order (post-order at the moment of writing, double check Operation::walk) is matched. If a matcher succeeds, the co-indexed action symbol is applied and the following matchers are not applied to the same payload operation. If the action succeeds, the next payload operation in walk order is matched. If it fails, both silenceable and definite errors are propagated as the result of this op.

The matcher symbol must take one operand of a type that implements the same transform dialect interface as the root operand (a check is performed at application time to see if the associated payload satisfies the constraints of the actual type). It must not consume the operand as multiple matchers may be applied. The matcher may produce any number of results. The action symbol paired with the matcher must take the same number of arguments as the matcher has results, and these arguments must implement the same transform dialect interfaces, but not necessarily have the exact same type (again, a check is performed at application time to see if the associated payload satisfies the constraints of actual types on both sides). The action symbol may not have results. The actions are expected to only modify payload operations nested in the root payload operations associated with the operand of this transform operation. Furhermore, the actions may not modify operations outside of the currently matched payload operation, e.g., they may not modify sibling or parent operations. If such behavior is desired, the parent must be matched first and the nested operations obtained by traversing the IR from the parent. This is due to the matching being performed as a post-order IR walk.

This operation consumes the operand and produces a new handle associated with the same payload. This is necessary to trigger invalidation of handles to any of the payload operations nested in the payload operations associated with the operand, as those are likely to be modified by actions. Note that the root payload operation associated with the operand are not matched.

The operation succeeds if none of the matchers produced a definite failure during application and if all of the applied actions produced success. Note that it also succeeds if all the matchers failed on all payload operations, i.e. failure to apply is not an error. The operation produces a silenceable failure if any applied action produced a silenceable failure. In this case, the resulting handle is associated with an empty payload. The operation produces a definite failure if any of the applied matchers or actions produced a definite failure.

Implementations

impl<'c> ForeachMatchOperation<'c>

pub fn name() -> &'static str

Returns a name.

pub fn as_operation(&self) -> &Operation<'c>

Returns a generic operation.

pub fn builder( context: &'c Context, location: Location<'c> ) -> ForeachMatchOperationBuilder<'c, Unset, Unset, Unset, Unset>

Creates a builder.

pub fn updated(&self) -> Result<OperationResult<'c, '_>, Error>

pub fn root(&self) -> Result<Value<'c, '_>, Error>

pub fn matchers(&self) -> Result<ArrayAttribute<'c>, Error>

pub fn set_matchers(&mut self, value: ArrayAttribute<'c>)

pub fn actions(&self) -> Result<ArrayAttribute<'c>, Error>

pub fn set_actions(&mut self, value: ArrayAttribute<'c>)

Trait Implementations

impl<'c> From<ForeachMatchOperation<'c>> for Operation<'c>

fn from(operation: ForeachMatchOperation<'c>) -> Self

Converts to this type from the input type.

impl<'c> TryFrom<Operation<'c>> for ForeachMatchOperation<'c>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(operation: Operation<'c>) -> Result<Self, Self::Error>

Performs the conversion.