Function write_new_vertex

atomic-core/src/apply/insertion.rs:86–222

Apply a Insertion atom to the graph. Creates a new span and connects it to the graph via context edges. This is how new content is inserted into files. # Arguments `txn` - Write transaction for graph modifications `workspace` - Workspace for tracking state and conflicts `change_id` - Internal ID of the change being applied `insertion` - The Insertion specification `change` - The full change for

(
    txn: &mut CachedWriteGraphTxn<'_, '_>,
    workspace: &mut Workspace,
    change_id: NodeId,
    insertion: &Insertion<Option<Hash>>,
    change: &Change,
    detect_conflicts: bool,
)

/// - `BlockNotFound`: Context position not found
/// - `Internal`: Database error
pub fn write_new_vertex(
    txn: &mut CachedWriteGraphTxn<'_, '_>,
    workspace: &mut Workspace,
    change_id: NodeId,
    insertion: &Insertion<Option<Hash>>,
    change: &Change,
    detect_conflicts: bool,
) -> Result<(), LocalApplyError> {
    // Create the new span
    let node = GraphNode {
        change: change_id,
        start: insertion.start,
        end: insertion.end,
    };

    // Clear workspace context for this span
    workspace.clear_context();

    // Fast path for the common "append one more line from this same change"
    // pattern used by large FileAdd chains. The predecessor is a vertex we
    // already inserted in this change, there are no successors, and the new
    // edge can be wired directly without re-running the general context walk.
    if insertion.successors.is_empty() && insertion.predecessors.len() == 1 {
        let internal_pos = resolve_position(txn, &insertion.predecessors[0], change_id)?;
        if let Some(up_vertex) = workspace.get_current_vertex(internal_pos, true) {
            let resolved_inode = resolve_inode(txn, &insertion.inode, change_id)?;
            let up_flag = insertion.flag | EdgeFlags::BLOCK;
            add_edge_with_reverse(txn, resolved_inode, up_flag, up_vertex, node, change_id)?;
            workspace.add_up_context(up_vertex.end_pos());
            workspace.add_up_context_vertex(up_vertex);
            workspace.register_current_vertex(node);
            return Ok(());
        }
    }

    // Resolve predecessors: vertices that come BEFORE this new content.
    // Uses the unified overlay-aware resolver so Local stacks can find
    // vertices written to GRAPH earlier in the same change.
    for up_pos in &insertion.predecessors {
        let internal_pos = resolve_position(txn, up_pos, change_id)?;
        let up_vertex = workspace
            .get_current_vertex(internal_pos, true)
            .unwrap_or(resolve_context_vertex(txn, internal_pos, true)?);
        // Store the end position (where new content connects)
        workspace.add_up_context(up_vertex.end_pos());
        workspace.add_up_context_vertex(up_vertex);

        // Check if predecessors was deleted by an unknown change
        if detect_conflicts {
            check_deleted_context(txn, workspace, change, up_vertex)?;
        }
    }

    let exact_inode_successor = resolve_position(txn, &insertion.inode, change_id).ok();

    // Resolve successors: vertices that come AFTER this new content.
    for down_pos in &insertion.successors {
        let internal_pos = resolve_position(txn, down_pos, change_id)?;