Struct cranelift_isle::sema::Rule

pub struct Rule {
    pub id: RuleId,
    pub root_term: TermId,
    pub args: Vec<Pattern>,
    pub iflets: Vec<IfLet>,
    pub rhs: Expr,
    pub vars: Vec<BoundVar>,
    pub prio: i64,
    pub pos: Pos,
}

A term rewrite rule.

Fields

id: RuleId

This rule’s id.

root_term: TermId

The left-hand side pattern that this rule matches.

args: Vec<Pattern>

Patterns to test against the root term’s arguments.

iflets: Vec<IfLet>

Any subpattern “if-let” clauses.

rhs: Expr

The right-hand side expression that this rule evaluates upon successful match.

vars: Vec<BoundVar>

Variable names used in this rule, indexed by VarId.

prio: i64

The priority of this rule, defaulted to 0 if it was missing in the source.

pos: Pos

The source position where this rule is defined.

Implementations

impl Rule

pub fn visit<V: RuleVisitor>(&self, visitor: &mut V, termenv: &TermEnv) -> V::Expr

Recursively visit every pattern and expression in this rule. Returns the RuleVisitor::Expr that was returned from RuleVisitor::add_expr when that function was called on the rule’s right-hand side.

Examples found in repository

src/ir.rs (line 421)

pub fn lower_rule(termenv: &TermEnv, rule: RuleId) -> (PatternSequence, ExprSequence) {
    let ruledata = &termenv.rules[rule.index()];
    log!("lower_rule: ruledata {:?}", ruledata);

    let mut pattern_seq = PatternSequence::default();
    let mut expr_seq = ruledata.visit(&mut pattern_seq, termenv).seq;
    expr_seq.pos = ruledata.pos;
    (pattern_seq, expr_seq)
}

src/trie_again.rs (line 296)

    fn add_rule(&mut self, rule: &sema::Rule, termenv: &sema::TermEnv, errors: &mut Vec<Error>) {
        self.current_rule.pos = rule.pos;
        self.current_rule.prio = rule.prio;
        self.current_rule.result = rule.visit(self, termenv);
        self.normalize_equivalence_classes();
        let rule = std::mem::take(&mut self.current_rule);

        if self.unreachable.is_empty() {
            self.rules.rules.push(rule);
        } else {
            // If this rule can never match, drop it so it doesn't affect overlap checking.
            errors.extend(
                self.unreachable
                    .drain(..)
                    .map(|err| Error::UnreachableError {
                        msg: format!(
                            "rule requires binding to match both {:?} and {:?}",
                            err.constraint_a, err.constraint_b
                        ),
                        span: Span::new_single(err.pos),
                    }),
            )
        }
    }

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Rule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.