// TODO: add deny(missing_docs)#![forbid(unsafe_code, rust_2018_idioms)] ///pub mod visit {    use git_object::immutable;     #[derive(Default, Clone)]    pub struct State {        buf1: Vec<u8>,        buf2: Vec<u8>,    }     pub struct Changes<'a>(Option<&'a immutable::Tree<'a>>);     impl<'a, T> From<T> for Changes<'a>    where        T: Into<Option<&'a immutable::Tree<'a>>>,    {        fn from(v: T) -> Self {            Changes(v.into())        }    }     mod changes {        use crate::visit;        use git_hash::{oid, ObjectId};        use git_object::immutable;        use quick_error::quick_error;         const EMPTY_TREE: immutable::Tree<'static> = immutable::Tree::empty();         quick_error! {            #[derive(Debug)]            pub enum Error {                NotFound(oid: ObjectId) {                    display("The object {} referenced by the tree was not found in the database", oid)                }                Cancelled {                    display("The delegate cancelled the operation")                }            }        }         impl<'a> visit::Changes<'a> {            /// Returns the changes that need to be applied to `self` to get `other`.            pub fn to_obtain_tree<LocateFn>(                &self,                _other: &git_object::immutable::Tree<'_>,                _state: &mut visit::State,                _locate: LocateFn,                _delegate: &mut impl visit::Record,            ) -> Result<(), Error>            where                LocateFn: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Option<immutable::Object<'b>>,            {                let _this = *self.0.as_ref().unwrap_or(&&EMPTY_TREE);                todo!("changes tree to tree")            }        }    }     pub mod record {        use git_hash::ObjectId;        use git_object::{bstr::BStr, tree};         pub enum Change {            Addition { mode: tree::Mode, oid: ObjectId },            Copy,            Deletion,            Modification,            Renaming,            Type,        }         #[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]        pub enum PathComponentMode {            Replace,            Push,        }         #[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]        pub struct PathComponent<'a> {            pub component: &'a BStr,            /// An ID referring uniquely to the path built thus far. Used to keep track of source paths            /// in case of [renames][Change::Rename] and [copies][Change::Copy].            pub id: usize,        }         #[derive(Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]        pub enum Action {            Continue,            Cancel,        }         pub trait Record {            fn update_path_component(&mut self, component: PathComponent<'_>, mode: PathComponentMode);            fn pop_path_component(&mut self);            fn record(change: Change) -> Action;        }         #[cfg(test)]        mod tests {            use super::*;             #[test]            fn size_of_change() {                assert_eq!(                    std::mem::size_of::<Change>(),                    22,                    "this type shouldn't grow without us knowing"                )            }        }    }    pub use record::Record;     pub mod recorder {        use crate::visit::record;         #[derive(Clone, Default)]        pub struct Recorder;         impl record::Record for Recorder {            fn update_path_component(                &mut self,                _component: record::PathComponent<'_>,                _mode: record::PathComponentMode,            ) {                todo!()            }             fn pop_path_component(&mut self) {                todo!()            }             fn record(_change: record::Change) -> record::Action {                todo!()            }        }    }    pub use recorder::Recorder;}