Method convert_token_changes

atomic-core/src/diff/semantic_to_crdt.rs:447–519

Convert token changes to LeafOps.

(
        &mut self,
        token_changes: &[TokenChange<'a>],
    )

    /// Convert token changes to LeafOps.
    fn convert_token_changes<'a>(
        &mut self,
        token_changes: &[TokenChange<'a>],
    ) -> ConversionResult<Vec<LeafOp>> {
        let mut leaf_ops = Vec::new();

        for tc in token_changes {
            match tc {
                TokenChange::Unchanged { token, .. } => {
                    if self.config.preserve_unchanged {
                        // Include unchanged tokens as inserts for complete reconstruction
                        if self.should_include_token(token.kind()) {
                            let _leaf_id = self.allocator.alloc_leaf();
                            leaf_ops.push(LeafOp::Insert {
                                after: None,
                                kind: token.kind(),
                                content: token.content().to_vec(),
                            });
                            self.stats.tokens_unchanged += 1;
                        }
                    }
                }

                TokenChange::Inserted { token, .. } => {
                    if self.should_include_token(token.kind()) {
                        let _leaf_id = self.allocator.alloc_leaf();
                        leaf_ops.push(LeafOp::Insert {
                            after: None,
                            kind: token.kind(),
                            content: token.content().to_vec(),
                        });
                        self.stats.tokens_inserted += 1;
                    }
                }

                TokenChange::Deleted { token, .. } => {
                    // For deletions, we record what was deleted
                    if self.should_include_token(token.kind()) {
                        let leaf_id = self.allocator.alloc_leaf();
                        leaf_ops.push(LeafOp::Delete { leaf: leaf_id });
                        self.stats.tokens_deleted += 1;
                    }
                }

                TokenChange::Replaced { new_token, .. } => {
                    if self.should_include_token(new_token.kind()) {
                        let leaf_id = self.allocator.alloc_leaf();

                        if self.config.use_replace_ops {
                            // Use a single Replace operation
                            leaf_ops.push(LeafOp::Replace {
                                leaf: leaf_id,
                                new_content: new_token.content().to_vec(),
                            });
                            self.stats.tokens_replaced += 1;
                        } else {
                            // Use Delete + Insert pair
                            leaf_ops.push(LeafOp::Delete { leaf: leaf_id });