Function select_linear_successor

atomic-repository/src/repository/content.rs:898–959

Choose the single live successor of `current` for a linear content walk. In the additive graph model a superseded span keeps its original alive `BLOCK` edge *alongside* a new `DELETED` edge. A walk that merely skipped `DELETED` edges would therefore still follow the alive edge into the superseded span and resurrect stale content. This helper instead treats any destination that has a visible `DELE

(
    txn: &T,
    inode: Inode,
    adj: &mut atomic_core::pristine::InodeAdjState,
    options: &atomic_core::output::alive::RetrieveOptions,
)

/// resolves to just the new span. Genuine conflict forks and delete-throughs
/// return [`LinearStep::Bail`] so the caller defers to the full graph walk.
fn select_linear_successor<T>(
    txn: &T,
    inode: Inode,
    adj: &mut atomic_core::pristine::InodeAdjState,
    options: &atomic_core::output::alive::RetrieveOptions,
) -> atomic_core::record::RecordResult<LinearStep>
where
    T: atomic_core::pristine::GraphTxnT + atomic_core::pristine::InodeGraphOps,
{
    use atomic_core::types::EdgeFlags;

    let mut alive: Vec<atomic_core::types::GraphNode<NodeId>> = Vec::new();
    let mut deleted: std::collections::HashSet<atomic_core::types::GraphNode<NodeId>> =
        std::collections::HashSet::new();

    while let Some(edge_result) = txn.next_inode_adj(adj) {
        let edge = match edge_result {
            Ok(edge) => edge,
            Err(_) => return Ok(LinearStep::Bail),
        };
        let flags = edge.flag();
        if flags.contains(EdgeFlags::PARENT)
            || flags.contains(EdgeFlags::PSEUDO)
            || flags.contains(EdgeFlags::FOLDER)
        {
            continue;
        }
        if !options.passes_filter(edge.introduced_by()) {
            continue;
        }
        let dest = match txn.find_block_in_inode(inode, edge.dest()) {
            Ok(Some(d)) => d,
            Ok(None) | Err(_) => return Ok(LinearStep::Bail),
        };
        if !options.passes_filter(dest.change) {
            continue;
        }
        if flags.contains(EdgeFlags::DELETED) {
            deleted.insert(dest);
        } else if !alive.contains(&dest) {
            alive.push(dest);
        }
    }

    // A destination that is both alive (original edge) and deleted (superseding
    // edge) is dead from this view's perspective.
    alive.retain(|d| !deleted.contains(d));

    match alive.len() {
        0 => {
            if deleted.is_empty() {
                Ok(LinearStep::End)
            } else {
                // The only successors here were deleted; the live continuation
                // lies past a dead vertex — defer to the full graph walk.
                Ok(LinearStep::Bail)
            }
        }