Method action

src/transform/src/normalize_lets.rs:98–190

Normalize `Let` and `LetRec` bindings in `relation`. Mechanically, `action` first renumbers all bindings, erroring if any shadowing is encountered. It then promotes all `Let` and `LetRec` expressions to the roots of their expressions, fusing `Let` bindings into containing `LetRec` bindings, but leaving stacked `LetRec` bindings unfused to each other (for reasons of correctness). It then considers

(
        &self,
        relation: &mut MirRelationExpr,
        features: &OptimizerFeatures,
    )

    ///
    /// We then perform a final renumbering.
    pub fn action(
        &self,
        relation: &mut MirRelationExpr,
        features: &OptimizerFeatures,
    ) -> Result<(), crate::TransformError> {
        // Record whether the relation was initially recursive, to confirm that we do not introduce
        // recursion to a non-recursive expression.
        let was_recursive = relation.is_recursive();

        // Renumber all bindings to ensure that identifier order matches binding order.
        // In particular, as we use `BTreeMap` for binding order, we want to ensure that
        // 1. Bindings within a `LetRec` are assigned increasing identifiers, and
        // 2. Bindings across `LetRec`s are assigned identifiers in "visibility order", corresponding to an
        // in-order traversal.
        // TODO: More can and perhaps should be said about "visibility order" and how let promotion is correct.
        renumbering::renumber_bindings(relation, &mut IdGen::default())?;

        // Promote all `Let` and `LetRec` AST nodes to the roots.
        // After this, all non-`LetRec` nodes contain no further `Let` or `LetRec` nodes,
        // placing all `LetRec` nodes around the root, if not always in a single AST node.
        let_motion::promote_let_rec(relation);
        let_motion::assert_no_lets(relation);
        let_motion::assert_letrec_major(relation);

        // Inlining may violate letrec-major form.
        inlining::inline_lets(relation, self.inline_mfp)?;

        // Return to letrec-major form to refresh types.
        let_motion::promote_let_rec(relation);
        support::refresh_types(relation, features)?;

        // Renumber bindings for good measure.
        // Ideally we could skip when `action` is a no-op, but hard to thread that through at the moment.
        renumbering::renumber_bindings(relation, &mut IdGen::default())?;

        // A final bottom-up traversal to normalize the shape of nested LetRec blocks
        relation.try_visit_mut_post(&mut |relation| -> Result<(), RecursionLimitError> {
            // Move a non-recursive suffix of bindings from the end of the LetRec
            // to the LetRec body.
            // This is unsafe when applied to expressions which contain `ArrangeBy`,
            // as if the extracted suffixes reference arrangements they will not be
            // able to access those arrangements from outside the `LetRec` scope.
            // It happens to work at the moment, so we don't touch it but should fix.
            let bindings = let_motion::harvest_nonrec_suffix(relation)?;
            if let MirRelationExpr::LetRec {
                ids: _,
                values: _,
                limits: _,
                body,
            } = relation
            {
                for (id, value) in bindings.into_iter().rev() {
                    **body = MirRelationExpr::Let {
                        id,
                        value: Box::new(value),
                        body: Box::new(body.take_dangerous()),
                    };
                }