在作用域解析遍历之后，我们可以使用三个关键的不变量

• Ir::Choose和Ir::Offer节点将不会有继续（它们的node.next字段始终是None）。
• Ir::Loop 节点始终具有非空的主体（在 Ir::Loop 变体内部的 Option<Index> 始终是 Some(body)）。
• 通过 Ir::Loop 节点主体的路径始终会在 Ir::Break 或 Ir::Continue 结束。

大多数其他流程都将利用这些假设。

作用域解析算法看起来像这样

fn resolve_scopes(implicit_scope, node) {
    if the node is a Recv, Send, Type, Break, Continue, Call, Split, or Error {
        // The implicit continuation of the callee of a Call node or arm of a Split node is always
        // Done, because we want to to run it until Done rather than to continue afterwards, as the
        // Call/Split node takes care of the continuation.
        if the node is a Call(callee) {
            resolve_scopes(None, callee);
        }

        if the node is a Split(tx, rx) {
            resolve_scopes(None, tx);
            resolve_scopes(None, rx);
        }

        // If this node has an explicit continuation, then we follow it and continue visiting! If it
        // doesn't, then we assign the implicit continuation in its scope to become its new explicit
        // continuation.
        match node.next {
            Some(next) => resolve_scopes(implicit_cont, next),
            None => node.next = implicit_scope,
        }
    } else if the node is a Choose(choices) or Offer(choices) {
        // Remove the continuation from the node if present; we inline it into all arms of the //
        // Choose/Offer.
        let cont = match node.next.take() {
            // If we find an implicit continuation, then it's the new "top of the continuation
            // scope" for this node's arms. In order to properly inline the outer scope's implicit
            // continuation, we visit the new implicit continuation w/ the previous one in order to
            // cause it to be inlined in the correct places as well.
            Some(next) => {
                resolve_scopes(implicit_cont, next);
                Some(next)
            }
            // If this node doesn't have an implicit continuation, then there's no need to worry
            // about inlining the outer scope's implicit continuation into it, as we can just inline
            // the outer implicit continuation into every arm instead.
            None => implicit_cont,
        };

        for choice in choices {
            resolve_scopes(cont, choice);
        }

        // We never follow or reassign a Choose/Offer node's implicit continuation, because it's
        // been inlined into all its arms already.
    } else if the node is a Loop(body) {
        // Inside a loop body, the absence of an explicit continuation doesn't imply following the
        // implicit continuation held by the scope outside the loop (the continuation of the loop
        // block) - instead, it implies continuing the loop! So to handle that, we visit the body of
        // the loop with its implicit continuation set to a Continue node we generate, targeted at
        // the loop node itself.
        let continue0 = Continue(node);
        continue0.machine_generated = true;
        resolve_scopes(continue0, body);
    }
}

// We begin w/ an empty implicit continuation (the Done continuation) and start traversing from the
// root.
resolve_scopes(None, root);

错误

此流程永远不会发出任何错误。

死代码报告 - Cfg::report_dead_code

死代码报告流程本身负责运行流分析可达性分析。在这些分析运行后，它从根节点遍历控制流图，寻找流分析认为“无法通过”的节点（控制流程不会继续到它们的后续节点），但它们仍然有后续节点。这为我们提供了所有包含可到达代码紧邻不可到达代码的程序点的位置，这对用户来说比看到每个不可到达节点（可能有很多相同的流程路径中的节点）的错误更容易。

死代码报告算法看起来像这样

fn report_dead_code(node) {
    // We want to follow every child node except for the node's continuation. If we did follow the
    // continuation, we would end up reporting every unreachable node instead of just the
    // unreachable nodes on the boundary between reachable and unreachable code.
    for child in all children of node {
        report_dead_code(child);
    }

    if let Some(cont) = node.next {
        if node is passable {
            report_dead_code(cont);
        } else if !cont.machine_generated && cont is not reachable {
            emit unreachable code errors;
        }
    }
}

report_dead_code(node);

错误

此流程发出两种类型的错误

• CompileError::FollowingCodeUnreachable - 在一个具有不可到达后续节点的可到达节点上发出
• CompileError::UnreachableStatement - 在一个不可到达的节点上发出，它是可到达节点的后续节点

降低到目标/目标代码生成 - Cfg::generate_target

代码生成/降低流程还执行循环生产率分析。一个无生产力的循环在技术上是一个有效的表面语言程序，但将导致 Rust 1.51 版本的 Rust 类型检查器无限循环并生成一个错误，这对于新用户来说很难理解。为了防止这种情况，我们检测它们并报告它们，而不是编译一个技术上有效的会话类型，该类型不会作为有效的 Rust 编译。

循环生产率分析在目标生成流程中进行，因为它是对目标语言本身的句法属性的分析。

对于大多数节点，生成相应的目标代码非常简单 - Send、Recv、Call、Split、Choose 和 Offer 都非常直接地映射到它们的 Target 对应项。复杂组件包括 Loop、Continue、Type、Break 和 Error

fn generate_target(loop_env, maybe_node) {
    if maybe_node is None {
        // If the node is empty, that's the "done" continuation.
        return Done;
    } else if maybe_node is Some(node) {
        if node is NOT Loop, Continue, Break {
            // Note that the current loop's target representation contains something which is not
            // another Loop in between itself and its `Continue` if present.
            loop_env.mark_productive();
        }

        if node is Recv, Send, Call, Split, Choose, or Offer {
            // Recursively call generate_target on child nodes and convert to the directly
            // corresponding Target.
            return Target:: ...;
        } else if node is Loop(body) {
            loop_env.push(node);
            let body = generate_target(loop_env, body);
            loop_env.pop(node);
            return Target::Loop(body);
        } else if node is Continue(jump_target) {
            let debruijn_index = loop_env.debruijn_index_of(jump_target);
            // If we've hit a continue, we can know whether or not the corresponding loop is
            // productive or not, and emit an error if not.
            if !loop_env.productive_for_continue(debruijn_index) {
                // Emit an error for the unproductive loop, and for the unproductive continue *if*
                // it is not machine generated
                ...
            }
            return Target::Continue(debruijn_index);
        } else if node is Break(jump_target) {
            // For a break, return the result of generating the target form of its corresponding
            // loop's continuation.
            return generate_target(loop_env, jump_target.next);
        } else if node is Type(ty) {
            // If the continuation is "done", then we don't need to emit a Then.
            if node.next is None {
                return Target::Type(ty);
            } else {
                let cont = generate_target(loop_env, node.next);
                return Target::Then(Target::Type(ty), );
            }
        } else if node is Error {
            // Just keep going so we can collect more loop productivity errors.
            return generate_target(loop_env, node.next);
        }
    }
}